language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/main.rb

@@ -2,19 +2,22 @@
 
 require 'thor'
 require 'fileutils'
+require_relative '../utils/secure_path'
 require_relative 'commands/cluster'
 require_relative 'commands/use'
-require_relative 'commands/agent'
+require_relative 'commands/agent/base'
 require_relative 'commands/status'
 require_relative 'commands/persona'
-require_relative 'commands/tool'
-require_relative 'commands/model'
+require_relative 'commands/tool/base'
+require_relative 'commands/model/base'
 require_relative 'commands/quickstart'
 require_relative 'commands/install'
-require_relative 'commands/system'
+require_relative 'commands/system/base'
 require_relative 'formatters/progress_formatter'
+require_relative 'helpers/ux_helper'
 require_relative '../config/cluster_config'
 require_relative '../kubernetes/client'
+require_relative 'errors/thor_errors'
 
 module LanguageOperator
   module CLI
@@ -22,6 +25,8 @@ module LanguageOperator
     #
     # Provides commands for creating, running, and managing language-operator resources.
     class Main < Thor
+      include Helpers::UxHelper
+
       def self.exit_on_failure?
         true
       end
@@ -33,11 +38,11 @@ module LanguageOperator
 
       desc 'version', 'Show aictl and operator version'
       def version
-        puts "aictl v#{LanguageOperator::VERSION}"
-        puts
-
-        # Try to get operator version from current cluster
+        # Check operator installation status first
         current_cluster = Config::ClusterConfig.current_cluster
+        operator_version = nil
+        operator_installed = false
+
         if current_cluster
           cluster_config = Config::ClusterConfig.get_cluster(current_cluster)
           begin
@@ -47,52 +52,46 @@ module LanguageOperator
             )
 
             if k8s.operator_installed?
+              operator_installed = true
               operator_version = k8s.operator_version || 'unknown'
-              puts "Operator: v#{operator_version}"
-              puts "Cluster:  #{current_cluster}"
-
-              # Check compatibility (simple version check)
-              # In the future, this could be more sophisticated
-              puts
-              Formatters::ProgressFormatter.success('Versions are compatible')
-            else
-              Formatters::ProgressFormatter.warn("Operator not installed in cluster '#{current_cluster}'")
             end
-          rescue StandardError => e
-            Formatters::ProgressFormatter.error("Could not connect to cluster: #{e.message}")
+          rescue StandardError
+            # Silently handle connection errors - we'll show appropriate message below
           end
+        end
+
+        # Show sparkly logo with appropriate subtitle
+        if operator_installed
+          logo(sparkle: true, title: "kubernetes language-operator detected (v#{operator_version})")
         else
-          puts 'No cluster selected'
-          puts
-          puts 'Select a cluster to check operator version:'
-          puts '  aictl use <cluster>'
+          logo(sparkle: true, title: 'kubernetes language-operator not found')
         end
       end
 
-      desc 'cluster SUBCOMMAND ...ARGS', 'Manage language clusters'
+      desc 'cluster SUBCOMMAND ...ARGS', 'Manage clusters'
       subcommand 'cluster', Commands::Cluster
 
-      desc 'use CLUSTER', 'Switch to a different cluster context'
+      desc 'use CLUSTER', 'Switch to a different cluster'
       def use(cluster_name)
         Commands::Use.new.switch(cluster_name)
       end
 
-      desc 'agent SUBCOMMAND ...ARGS', 'Manage autonomous agents'
-      subcommand 'agent', Commands::Agent
+      desc 'agent SUBCOMMAND ...ARGS', 'Manage agents'
+      subcommand 'agent', Commands::Agent::Base
 
-      desc 'persona SUBCOMMAND ...ARGS', 'Manage agent personas'
+      desc 'persona SUBCOMMAND ...ARGS', 'Manage personas'
       subcommand 'persona', Commands::Persona
 
-      desc 'tool SUBCOMMAND ...ARGS', 'Manage MCP tools'
-      subcommand 'tool', Commands::Tool
+      desc 'tool SUBCOMMAND ...ARGS', 'Manage tools'
+      subcommand 'tool', Commands::Tool::Base
 
-      desc 'model SUBCOMMAND ...ARGS', 'Manage language models'
-      subcommand 'model', Commands::Model
+      desc 'model SUBCOMMAND ...ARGS', 'Manage models'
+      subcommand 'model', Commands::Model::Base
 
-      desc 'system SUBCOMMAND ...ARGS', 'System commands for schema and metadata'
-      subcommand 'system', Commands::System
+      desc 'system SUBCOMMAND ...ARGS', 'System utilities'
+      subcommand 'system', Commands::System::Base
 
-      desc 'quickstart', 'Interactive setup wizard for first-time users'
+      desc 'quickstart', 'Wizard for first-time users'
       def quickstart
         Commands::Quickstart.new.invoke(:start)
       end
@@ -157,13 +156,24 @@ module LanguageOperator
         when 'fish'
           install_fish_completion
         else
-          Formatters::ProgressFormatter.error("Unsupported shell: #{shell}")
+          message = "Unsupported shell: #{shell}"
+          Formatters::ProgressFormatter.error(message)
           puts
           puts 'Supported shells: bash, zsh, fish'
-          exit 1
+          raise Errors::ValidationError, message
         end
       end
 
+      def help(command = nil, subcommand = false)
+        if command.nil? && !subcommand
+          # Show logo when displaying general help (no specific command)
+          logo
+        end
+
+        # Delegate to Thor's original help method
+        super
+      end
+
       private
 
       def install_bash_completion
@@ -174,7 +184,7 @@ module LanguageOperator
           return
         end
 
-        target = File.expand_path('~/.bash_completion.d/aictl')
+        target = LanguageOperator::Utils::SecurePath.expand_home_path('.bash_completion.d/aictl')
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.cp(completion_file, target)
 
@@ -196,7 +206,7 @@ module LanguageOperator
         end
 
         # Check if user has a custom fpath directory
-        fpath_dir = File.expand_path('~/.zsh/completions')
+        fpath_dir = LanguageOperator::Utils::SecurePath.expand_home_path('.zsh/completions')
         FileUtils.mkdir_p(fpath_dir)
 
         target = File.join(fpath_dir, '_aictl')
@@ -220,7 +230,7 @@ module LanguageOperator
           return
         end
 
-        target = File.expand_path('~/.config/fish/completions/aictl.fish')
+        target = LanguageOperator::Utils::SecurePath.expand_home_path('.config/fish/completions/aictl.fish')
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.cp(completion_file, target)
 

data/lib/language_operator/cli/templates/tools/generic.yaml

@@ -4,6 +4,9 @@ metadata:
   name: <%= name %>
   namespace: <%= namespace %>
 spec:
+<% if cluster_ref -%>
+  clusterRef: <%= cluster_ref %>
+<% end -%>
   type: <%= type || 'mcp' %>
   image: <%= image || "changeme/#{name}-tool:latest" %>
   imagePullPolicy: Always

data/lib/language_operator/cli/wizards/agent_wizard.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
-require 'tty-prompt'
-require 'pastel'
 require_relative '../helpers/schedule_builder'
+require_relative '../helpers/ux_helper'
 
 module LanguageOperator
   module CLI
     module Wizards
       # Interactive wizard for creating agents
       class AgentWizard
-        attr_reader :prompt, :pastel
+        include Helpers::UxHelper
 
         def initialize
-          @prompt = TTY::Prompt.new
-          @pastel = Pastel.new
+          # UxHelper provides pastel and prompt methods
         end
 
         # Run the wizard and return the generated description
@@ -42,11 +40,7 @@ module LanguageOperator
         private
 
         def show_welcome
-          puts
-          puts pastel.cyan('╭────────────────────────────────────────╮')
-          puts pastel.cyan('│  Let\'s create your agent! 🤖           │')
-          puts pastel.cyan('╰────────────────────────────────────────╯')
-          puts
+          logo(title: 'create an agent')
         end
 
         def ask_task_description
@@ -216,23 +210,21 @@ module LanguageOperator
 
         def show_preview(description, schedule_info, tools_config)
           puts
-          puts pastel.cyan('╭─ Preview ──────────────────────────────╮')
-          puts '│'
-          puts "│  #{pastel.bold('Task:')} #{description}"
+
+          content = []
+          content << "#{pastel.bold('Task:')} #{description}"
 
           if schedule_info[:type] == :manual
-            puts "│  #{pastel.bold('Mode:')} Manual trigger"
+            content << "#{pastel.bold('Mode:')} Manual trigger"
           else
             schedule_text = schedule_info[:description] || 'on demand'
-            puts "│  #{pastel.bold('Schedule:')} #{schedule_text}"
+            content << "#{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?
+          content << "#{pastel.bold('Cron:')} #{pastel.dim(schedule_info[:cron])}" if schedule_info[:cron]
+          content << "#{pastel.bold('Tools:')} #{tools_config[:tools].join(', ')}" if tools_config[:tools]&.any?
 
-          puts '│'
-          puts pastel.cyan('╰────────────────────────────────────────╯')
+          puts box(content.join("\n"), title: 'Preview')
           puts
         end
 

data/lib/language_operator/cli/wizards/model_wizard.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/ux_helper'
+require_relative '../helpers/validation_helper'
+require_relative '../helpers/provider_helper'
+require_relative '../formatters/progress_formatter'
+require_relative '../../kubernetes/client'
+require_relative '../../kubernetes/resource_builder'
+
+module LanguageOperator
+  module CLI
+    module Wizards
+      # Interactive wizard for creating language models
+      #
+      # Guides users through provider selection, credential input,
+      # model selection, and resource creation.
+      #
+      # @example
+      #   wizard = Wizards::ModelWizard.new(ctx)
+      #   wizard.run
+      class ModelWizard
+        include Helpers::UxHelper
+        include Helpers::ValidationHelper
+        include Helpers::ProviderHelper
+
+        attr_reader :ctx
+
+        def initialize(ctx)
+          @ctx = ctx
+        end
+
+        # Run the wizard and create the model
+        #
+        # @return [Boolean] true if model was created successfully
+        def run
+          show_welcome
+
+          # Step 1: Provider selection
+          provider_info = select_provider
+          return false unless provider_info
+
+          # Step 2: Get credentials
+          credentials = get_credentials(provider_info)
+          return false unless credentials
+
+          # Step 3: Test connection
+          test_result = test_connection(provider_info, credentials)
+          return false unless test_result[:success]
+
+          # Step 4: Select model
+          model_id = select_model(provider_info, credentials)
+          return false unless model_id
+
+          # Step 5: Get display name
+          model_name = get_model_name(model_id)
+          return false unless model_name
+
+          # Create resources
+          success = create_model_resource(model_name, provider_info, credentials, model_id)
+          return false unless success
+
+          # Show success
+          show_success(model_name, model_id, provider_info)
+
+          true
+        end
+
+        private
+
+        def show_welcome
+          logo(title: "add a model to cluster '#{ctx.name}'")
+        end
+
+        def select_provider
+          provider = prompt.select('Select a provider:') do |menu|
+            menu.choice 'Anthropic', :anthropic
+            menu.choice 'OpenAI', :openai
+            menu.choice 'Other (OpenAI-compatible)', :openai_compatible
+          end
+
+          case provider
+          when :anthropic
+            { provider: :anthropic, provider_key: 'anthropic', display_name: 'Anthropic' }
+          when :openai
+            { provider: :openai, provider_key: 'openai', display_name: 'OpenAI' }
+          when :openai_compatible
+            endpoint = ask_url('API endpoint URL (e.g., http://localhost:11434):')
+            return nil unless endpoint
+
+            { provider: :openai_compatible, provider_key: 'openai-compatible',
+              display_name: 'OpenAI-Compatible', endpoint: endpoint }
+          end
+        rescue TTY::Reader::InputInterrupt
+          Formatters::ProgressFormatter.error('Cancelled')
+          nil
+        end
+
+        def get_credentials(provider_info)
+          case provider_info[:provider]
+          when :anthropic
+            show_credential_help('Anthropic', 'https://console.anthropic.com')
+            api_key = ask_secret('Enter your Anthropic API key:')
+            return nil unless api_key
+
+            { api_key: api_key }
+          when :openai
+            show_credential_help('OpenAI', 'https://platform.openai.com/api-keys')
+            api_key = ask_secret('Enter your OpenAI API key:')
+            return nil unless api_key
+
+            { api_key: api_key }
+          when :openai_compatible
+            needs_auth = ask_yes_no('Does this endpoint require authentication?', default: false)
+            return nil if needs_auth.nil?
+
+            api_key = needs_auth ? ask_secret('Enter API key:') : nil
+            { api_key: api_key, endpoint: provider_info[:endpoint] }
+          end
+        end
+
+        def show_credential_help(_provider_name, url)
+          puts "If you need to, get your API key at #{pastel.cyan(url)}."
+          puts
+        end
+
+        def test_connection(provider_info, credentials)
+          puts
+          test_result = Formatters::ProgressFormatter.with_spinner('Testing connection') do
+            test_provider_connection(
+              provider_info[:provider],
+              api_key: credentials[:api_key],
+              endpoint: provider_info[:endpoint]
+            )
+          end
+
+          unless test_result[:success]
+            Formatters::ProgressFormatter.error("Connection failed: #{test_result[:error]}")
+            puts
+            retry_choice = ask_yes_no('Try again with different credentials?', default: false)
+            if retry_choice
+              new_credentials = get_credentials(provider_info)
+              return { success: false } unless new_credentials
+
+              return test_connection(provider_info, new_credentials)
+            end
+            return { success: false }
+          end
+
+          puts
+          { success: true }
+        end
+
+        def select_model(provider_info, credentials)
+          available_models = fetch_provider_models(
+            provider_info[:provider],
+            api_key: credentials[:api_key],
+            endpoint: provider_info[:endpoint]
+          )
+
+          if available_models.nil? || available_models.empty?
+            Formatters::ProgressFormatter.warn('Could not fetch available models')
+            puts
+            model_id = prompt.ask('Enter model identifier manually:') do |q|
+              q.required true
+            end
+            return model_id
+          end
+
+          ask_select('Select a model:', available_models, per_page: 10)
+        rescue TTY::Reader::InputInterrupt
+          Formatters::ProgressFormatter.error('Cancelled')
+          nil
+        end
+
+        def get_model_name(model_id)
+          # Generate smart default from model_id
+          # Examples: "gpt-4-turbo" -> "gpt-4-turbo", "claude-3-opus-20240229" -> "claude-3-opus-20240229"
+          #           "mistralai/magistral-small-2509" -> "magistral-small-2509"
+          default_name = model_id.split('/').last.downcase.gsub(/[^0-9a-z]/i, '-').gsub(/-+/, '-')
+          default_name = default_name[0..62] if default_name.length > 63 # K8s limit is 63 chars
+
+          ask_k8s_name('Your name for this model:', default: default_name)
+        rescue TTY::Reader::InputInterrupt
+          Formatters::ProgressFormatter.error('Cancelled')
+          nil
+        end
+
+        def create_model_resource(model_name, provider_info, credentials, model_id)
+          # Check if model already exists
+          begin
+            ctx.client.get_resource('LanguageModel', model_name, ctx.namespace)
+            Formatters::ProgressFormatter.error("Model '#{model_name}' already exists in cluster '#{ctx.name}'")
+            puts
+            puts "Use 'aictl model inspect #{model_name}' to view details"
+            puts "Use 'aictl model edit #{model_name}' to modify it"
+            return false
+          rescue K8s::Error::NotFound
+            # Expected - model doesn't exist yet
+          end
+
+          puts
+          Formatters::ProgressFormatter.with_spinner("Creating model '#{model_name}'") do
+            # Create API key secret if provided
+            if credentials[:api_key]
+              secret_name = "#{model_name}-api-key"
+              secret = {
+                'apiVersion' => 'v1',
+                'kind' => 'Secret',
+                'metadata' => {
+                  'name' => secret_name,
+                  'namespace' => ctx.namespace
+                },
+                'type' => 'Opaque',
+                'stringData' => {
+                  'api-key' => credentials[:api_key]
+                }
+              }
+              ctx.client.apply_resource(secret)
+            end
+
+            # Create LanguageModel resource
+            resource = Kubernetes::ResourceBuilder.language_model(
+              model_name,
+              provider: provider_info[:provider_key],
+              model: model_id,
+              endpoint: provider_info[:endpoint],
+              cluster: ctx.namespace
+            )
+
+            # Add API key reference if secret was created
+            if credentials[:api_key]
+              resource['spec']['apiKeySecret'] = {
+                'name' => "#{model_name}-api-key",
+                'key' => 'api-key'
+              }
+            end
+
+            ctx.client.apply_resource(resource)
+          end
+
+          true
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to create model: #{e.message}")
+          false
+        end
+
+        def show_success(model_name, model_id, provider_info)
+          puts
+          highlighted_box(
+            title: 'LanguageModel Details',
+            rows: {
+              'Name' => model_name,
+              'Provider' => provider_info[:display_name],
+              'Model' => model_id,
+              'Endpoint' => provider_info[:endpoint],
+              'Cluster' => ctx.name
+            }
+          )
+          puts
+          puts 'Next steps:'
+          puts
+          puts '1. Use this model in an agent:'
+          puts "   #{pastel.dim("aictl agent create --model #{model_name}")}"
+          puts '2. View model details:'
+          puts "   #{pastel.dim("aictl model inspect #{model_name}")}"
+          puts
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/wizards/quickstart_wizard.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
-require 'tty-prompt'
-require 'pastel'
 require 'k8s-ruby'
 require_relative '../formatters/progress_formatter'
+require_relative '../helpers/ux_helper'
 require_relative '../../config/cluster_config'
 require_relative '../../kubernetes/client'
 require_relative '../../kubernetes/resource_builder'
+require_relative '../../utils/secure_path'
 
 module LanguageOperator
   module CLI
     module Wizards
       # Interactive quickstart wizard for first-time setup
       class QuickstartWizard
+        include Helpers::UxHelper
+
         def initialize
-          @prompt = TTY::Prompt.new
-          @pastel = Pastel.new
+          # UxHelper provides pastel and prompt methods
         end
 
         def run
@@ -38,31 +39,11 @@ module LanguageOperator
 
         private
 
-        attr_reader :prompt, :pastel
-
         def show_welcome
-          puts
-          puts pastel.cyan('╭────────────────────────────────────────────────╮')
-          puts "#{pastel.cyan('│')}  Welcome to Language Operator! 🎉              #{pastel.cyan('│')}"
-          puts "#{pastel.cyan('│')}  Let's get you set up (takes ~5 minutes)       #{pastel.cyan('│')}"
-          puts pastel.cyan('╰────────────────────────────────────────────────╯')
-          puts
-          puts 'This wizard will help you:'
-          puts '  1. Connect to your Kubernetes cluster'
-          puts '  2. Configure a language model'
-          puts '  3. Create your first autonomous agent'
-          puts
-          puts pastel.dim('Press Enter to begin...')
-          $stdin.gets
+          logo(title: 'cluster setup quick start')
         end
 
         def setup_cluster
-          puts
-          puts '─' * 50
-          puts pastel.cyan('Step 1/3: Connect to Kubernetes')
-          puts '─' * 50
-          puts
-
           # Check if user has kubectl configured
           has_kubectl = prompt.yes?('Do you have kubectl configured?')
 
@@ -99,7 +80,7 @@ module LanguageOperator
         end
 
         def get_kubectl_contexts
-          kubeconfig_path = ENV.fetch('KUBECONFIG', File.expand_path('~/.kube/config'))
+          kubeconfig_path = ENV.fetch('KUBECONFIG', LanguageOperator::Utils::SecurePath.expand_home_path('.kube/config'))
 
           return [] unless File.exist?(kubeconfig_path)
 
@@ -111,7 +92,7 @@ module LanguageOperator
         end
 
         def create_cluster_config(name, context)
-          kubeconfig_path = ENV.fetch('KUBECONFIG', File.expand_path('~/.kube/config'))
+          kubeconfig_path = ENV.fetch('KUBECONFIG', LanguageOperator::Utils::SecurePath.expand_home_path('.kube/config'))
 
           Formatters::ProgressFormatter.with_spinner("Creating cluster '#{name}'") do
             # Create Kubernetes client to verify connection
@@ -138,13 +119,6 @@ module LanguageOperator
 
             { name: name, namespace: namespace, kubeconfig: kubeconfig_path, context: context, k8s: k8s }
           end
-
-          {
-            name: name,
-            namespace: (kubeconfig_path && K8s::Config.load_file(kubeconfig_path).context(context).namespace) || 'default',
-            kubeconfig: kubeconfig_path,
-            context: context
-          }
         rescue StandardError => e
           puts
           Formatters::ProgressFormatter.error("Failed to connect: #{e.message}")

data/lib/language_operator/client/base.rb

@@ -168,6 +168,34 @@ module LanguageOperator
         @debug
       end
 
+      # Cleanup all MCP connections and reset client state
+      #
+      # This method properly closes all MCP client connections and clears
+      # the @clients array to prevent resource leaks. Should be called
+      # when the client is no longer needed.
+      #
+      # @return [void]
+      def cleanup_connections
+        return if @clients.empty?
+
+        logger.debug('Cleaning up MCP connections', client_count: @clients.length)
+
+        @clients.each do |client|
+          # Close the client connection if it responds to close
+          client.close if client.respond_to?(:close)
+        rescue StandardError => e
+          logger.warn('Error closing MCP client connection',
+                      client: client.class.name,
+                      error: e.message)
+        end
+
+        # Clear the clients array and chat session
+        @clients.clear
+        @chat = nil
+
+        logger.debug('MCP connections cleanup completed')
+      end
+
       private
 
       def logger_component

data/lib/language_operator/client/config.rb

@@ -24,7 +24,10 @@ module LanguageOperator
       # @return [Hash] Configuration hash
       # @raise [Errno::ENOENT] If file doesn't exist
       def self.load(path)
-        YAML.load_file(path)
+        config = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
+        # Normalize structure to ensure defaults
+        config['mcp_servers'] ||= []
+        config
       end
 
       # Load configuration from environment variables

data/lib/language_operator/client/mcp_connector.rb

@@ -10,7 +10,7 @@ module LanguageOperator
       #
       # @return [void]
       def connect_mcp_servers
-        enabled_servers = @config['mcp_servers'].select { |s| s['enabled'] }
+        enabled_servers = (@config['mcp_servers'] || []).select { |s| s['enabled'] }
 
         if enabled_servers.empty?
           logger.info('No MCP servers configured, agent will run without tools')