language-operator 0.1.61 → 0.1.62

data/lib/language_operator/ux/base.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-prompt'
-require 'pastel'
-require_relative '../cli/formatters/progress_formatter'
-
-module LanguageOperator
-  module Ux
-    # Base class for interactive user experience flows
-    #
-    # Provides common infrastructure for TTY-based interactive wizards
-    # including cluster context validation and standard UI helpers.
-    #
-    # @example Creating a new UX flow
-    #   class CreateModel < Base
-    #     def execute
-    #       show_welcome
-    #       # ... flow logic
-    #     end
-    #   end
-    #
-    # @example Using a UX flow
-    #   Ux::CreateModel.execute(ctx)
-    #
-    class Base
-      attr_reader :prompt, :pastel, :ctx
-
-      # Initialize the UX flow
-      #
-      # @param ctx [Object, nil] Cluster context (required unless overridden)
-      def initialize(ctx = nil)
-        @prompt = TTY::Prompt.new
-        @pastel = Pastel.new
-        @ctx = ctx
-
-        validate_cluster_context! if requires_cluster?
-      end
-
-      # Execute the UX flow
-      #
-      # Subclasses must override this method to implement their flow logic.
-      #
-      # @raise [NotImplementedError] if not overridden by subclass
-      def execute
-        raise NotImplementedError, "#{self.class.name} must implement #execute"
-      end
-
-      # Execute the UX flow as a class method
-      #
-      # @param ctx [Object, nil] Cluster context
-      # @return [Object] Result of execute method
-      def self.execute(ctx = nil)
-        new(ctx).execute
-      end
-
-      private
-
-      # Whether this flow requires a cluster context
-      #
-      # Subclasses can override to disable cluster requirement (e.g., Quickstart).
-      #
-      # @return [Boolean] true if cluster is required
-      def requires_cluster?
-        true
-      end
-
-      # Validate that a cluster context is available
-      #
-      # Exits with error if cluster is required but not provided.
-      def validate_cluster_context!
-        return unless requires_cluster?
-        return if ctx
-
-        CLI::Formatters::ProgressFormatter.error(
-          'No cluster selected. Run "aictl cluster add" first.'
-        )
-        exit 1
-      end
-    end
-  end
-end

data/lib/language_operator/ux/concerns/README.md

@@ -1,155 +0,0 @@
-# Ux::Concerns
-
-Reusable mixins for interactive UX flows.
-
-## Available Concerns
-
-### Headings
-
-Provides consistent formatting for headings, step indicators, and banners.
-
-```ruby
-class MyFlow < Ux::Base
-  include Concerns::Headings
-
-  def execute
-    heading('Welcome!', emoji: '🎉')
-    step_heading(1, 3, 'First Step')
-    subheading('Configuration')
-    separator
-  end
-end
-```
-
-**Methods:**
-- `heading(text, emoji: nil, width: 50)` - Display prominent heading with border
-- `step_heading(current, total, title, width: 50)` - Display step indicator
-- `subheading(text)` - Display simple subheading
-- `separator(width: 50, char: '─')` - Display separator line
-- `section(title, description: nil)` - Display section header with description
-
-### ProviderHelpers
-
-Common operations for LLM provider integration.
-
-```ruby
-class MyFlow < Ux::Base
-  include Concerns::ProviderHelpers
-
-  def execute
-    result = test_provider_connection(:anthropic, api_key: 'sk-...')
-    models = fetch_provider_models(:openai, api_key: 'sk-...')
-    info = provider_info(:anthropic)
-  end
-end
-```
-
-**Methods:**
-- `test_provider_connection(provider, api_key:, endpoint:)` - Test connection to provider
-- `fetch_provider_models(provider, api_key:, endpoint:)` - Fetch available models
-- `provider_info(provider)` - Get provider display info and documentation URLs
-
-**Supported Providers:**
-- `:anthropic` - Anthropic (Claude)
-- `:openai` - OpenAI (GPT)
-- `:openai_compatible` - OpenAI-compatible endpoints (Ollama, vLLM, LM Studio, etc)
-
-### InputValidation
-
-Common input validation and prompting helpers.
-
-```ruby
-class MyFlow < Ux::Base
-  include Concerns::InputValidation
-
-  def execute
-    url = ask_url('Enter endpoint URL:')
-    name = ask_k8s_name('Resource name:', default: 'my-resource')
-    email = ask_email('Your email:')
-    api_key = ask_secret('API key:')
-    port = ask_port('Port:', default: 8080)
-    confirmed = ask_yes_no('Continue?', default: true)
-  end
-end
-```
-
-**Methods:**
-- `ask_url(question, default:, required:)` - Prompt for URL with validation
-- `ask_k8s_name(question, default:)` - Prompt for Kubernetes resource name
-- `ask_email(question, default:)` - Prompt for email address
-- `ask_secret(question, required:)` - Prompt for masked input (API keys, passwords)
-- `ask_port(question, default:)` - Prompt for port number (1-65535)
-- `ask_yes_no(question, default:)` - Prompt for yes/no confirmation
-- `ask_select(question, choices, per_page:)` - Prompt for selection from list
-- `validate_k8s_name(name)` - Validate and normalize Kubernetes name
-- `validate_url(url)` - Validate URL format
-
-## Usage Guidelines
-
-### When to Use Concerns
-
-✅ **DO use concerns for:**
-- Common formatting patterns used across multiple flows
-- Repeated validation logic
-- Shared provider/API operations
-- Reusable UI components
-
-❌ **DON'T use concerns for:**
-- Flow-specific business logic
-- One-off operations
-- Complex state management
-
-### Naming Convention
-
-Concerns should be:
-- Named as adjectives or capabilities (e.g., `Headings`, `ProviderHelpers`)
-- Focused on a single responsibility
-- Well-documented with examples
-
-### Testing
-
-Each concern should have corresponding specs in `spec/language_operator/ux/concerns/`.
-
-## Creating New Concerns
-
-1. Create file in `lib/language_operator/ux/concerns/my_concern.rb`
-2. Define module under `LanguageOperator::Ux::Concerns`
-3. Add YARD documentation with examples
-4. Include in flows via `include Concerns::MyConcern`
-5. Add tests in `spec/language_operator/ux/concerns/my_concern_spec.rb`
-6. Update this README
-
-## Example: Creating a New Concern
-
-```ruby
-# lib/language_operator/ux/concerns/kubernetes_helpers.rb
-module LanguageOperator
-  module Ux
-    module Concerns
-      # Mixin for Kubernetes resource operations
-      module KubernetesHelpers
-        def resource_exists?(type, name)
-          ctx.client.get_resource(type, name, ctx.namespace)
-          true
-        rescue K8s::Error::NotFound
-          false
-        end
-      end
-    end
-  end
-end
-```
-
-Then use it:
-
-```ruby
-class CreateAgent < Base
-  include Concerns::KubernetesHelpers
-
-  def execute
-    if resource_exists?('LanguageAgent', 'my-agent')
-      puts "Agent already exists!"
-    end
-  end
-end
-```

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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module LanguageOperator
-  module Ux
-    module Concerns
-      # Mixin for consistent heading and banner formatting in UX flows
-      #
-      # Provides helpers for creating section headers, step indicators,
-      # welcome banners, and separator lines.
-      #
-      # @example
-      #   class MyFlow < Base
-      #     include Concerns::Headings
-      #
-      #     def execute
-      #       heading('Welcome to My Flow', emoji: '🎉')
-      #       step_heading(1, 5, 'First Step')
-      #       # ... flow logic
-      #     end
-      #   end
-      module Headings
-        def title(text)
-          puts
-          puts pastel.bold.green("LANGUAGE OPERATOR v#{LanguageOperator::VERSION}")
-          puts pastel.dim("↪ #{text}")
-        end
-
-        # Display a prominent heading with optional emoji
-        #
-        # @param text [String] The heading text
-        # @param emoji [String, nil] Optional emoji to display
-        # @param width [Integer] Width of the banner (default: 50)
-        def heading(text, emoji: nil, width: 50)
-          border = "╭#{'─' * (width - 2)}╮"
-          bottom = "╰#{'─' * (width - 2)}╯"
-
-          display_text = emoji ? "#{text} #{emoji}" : text
-          padding = width - display_text.length - 4
-
-          puts
-          puts pastel.cyan(border)
-          puts "#{pastel.cyan('│')}  #{display_text}#{' ' * padding}#{pastel.cyan('│')}"
-          puts pastel.cyan(bottom)
-          puts
-        end
-
-        # Display a step heading with step number
-        #
-        # @param current [Integer] Current step number
-        # @param total [Integer] Total number of steps
-        # @param title [String] Step title
-        # @param width [Integer] Width of the separator line (default: 50)
-        def step_heading(current, total, title, width: 50)
-          puts
-          puts '─' * width
-          puts pastel.cyan("Step #{current}/#{total}: #{title}")
-          puts '─' * width
-          puts
-        end
-
-        # Display a simple subheading
-        #
-        # @param text [String] The subheading text
-        def subheading(text)
-          puts
-          puts pastel.bold(text)
-        end
-
-        # Display a separator line
-        #
-        # @param width [Integer] Width of the line (default: 50)
-        # @param char [String] Character to use for the line (default: '─')
-        def separator(width: 50, char: '─')
-          puts char * width
-        end
-
-        # Display a section header with description
-        #
-        # @param title [String] Section title
-        # @param description [String, nil] Optional description
-        def section(title, description: nil)
-          puts
-          puts pastel.cyan.bold(title)
-          puts pastel.dim(description) if description
-          puts
-        end
-      end
-    end
-  end
-end

data/lib/language_operator/ux/create_agent.rb

@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-require_relative 'concerns/headings'
-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
-      include Concerns::Headings
-
-      # 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