language-operator 0.1.81 → 0.1.82

data/lib/language_operator/cli/helpers/health_checker.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative '../formatters/progress_formatter'
+
+module LanguageOperator
+  module CLI
+    module Helpers
+      # Health checker for Language Operator components
+      class HealthChecker
+        attr_reader :k8s, :namespace, :cluster_name, :cluster_namespace
+
+        def initialize(k8s_client, namespace, cluster_name = nil, cluster_namespace = nil)
+          @k8s = k8s_client
+          @namespace = namespace
+          @cluster_name = cluster_name
+          @cluster_namespace = cluster_namespace
+        end
+
+        # Check dashboard deployment health
+        def check_dashboard_health
+          deployment = @k8s.client.api('apps/v1')
+                               .resource('deployments', namespace: @namespace)
+                               .get('language-operator-dashboard')
+
+          ready_replicas = deployment.dig('status', 'readyReplicas') || 0
+          desired_replicas = deployment.dig('spec', 'replicas') || 0
+
+          {
+            healthy: ready_replicas == desired_replicas && desired_replicas > 0,
+            ready_replicas: ready_replicas,
+            desired_replicas: desired_replicas
+          }
+        rescue K8s::Error::NotFound
+          { healthy: false, error: 'Dashboard deployment not found' }
+        rescue StandardError => e
+          { healthy: false, error: e.message }
+        end
+
+        # Check operator deployment health
+        def check_operator_health
+          deployment = @k8s.client.api('apps/v1')
+                               .resource('deployments', namespace: @namespace)
+                               .get('language-operator')
+
+          ready_replicas = deployment.dig('status', 'readyReplicas') || 0
+          desired_replicas = deployment.dig('spec', 'replicas') || 0
+
+          {
+            healthy: ready_replicas == desired_replicas && desired_replicas > 0,
+            ready_replicas: ready_replicas,
+            desired_replicas: desired_replicas
+          }
+        rescue K8s::Error::NotFound
+          { healthy: false, error: 'Operator deployment not found' }
+        rescue StandardError => e
+          { healthy: false, error: e.message }
+        end
+
+        # Check ClickHouse health and authentication
+        def check_clickhouse_health
+          # First check if service exists
+          begin
+            @k8s.client.api('v1')
+                       .resource('services', namespace: @namespace)
+                       .get('language-operator-clickhouse')
+          rescue K8s::Error::NotFound
+            return { healthy: false, error: 'ClickHouse service not found' }
+          end
+
+          # Try to connect and authenticate using port-forward
+          require 'net/http'
+          require 'uri'
+          require 'open3'
+
+          port = find_available_port
+          pf_pid = nil
+
+          begin
+            # Start port-forward in background
+            pf_command = "kubectl port-forward -n #{@namespace} service/language-operator-clickhouse #{port}:8123"
+            pf_stdin, pf_stdout, pf_stderr, pf_thread = Open3.popen3(pf_command)
+
+            # Give port-forward time to establish
+            sleep(2)
+
+            # Test connection with credentials
+            uri = URI("http://localhost:#{port}/ping")
+            
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.read_timeout = 5
+            http.open_timeout = 5
+
+            # Try with auth (default ClickHouse credentials for Language Operator)
+            request = Net::HTTP::Get.new(uri)
+            request.basic_auth('langop', 'langop')
+            
+            response = http.request(request)
+            
+            {
+              healthy: response.code == '200',
+              auth_works: response.code == '200',
+              response_code: response.code
+            }
+          rescue StandardError => e
+            { healthy: false, error: e.message }
+          ensure
+            # Clean up port-forward
+            if pf_thread&.alive?
+              Process.kill('TERM', pf_thread.pid) rescue nil
+              pf_thread.join(1)
+            end
+          end
+        end
+
+        # Check PostgreSQL health and authentication  
+        def check_postgres_health
+          # First check if service exists
+          begin
+            @k8s.client.api('v1')
+                       .resource('services', namespace: @namespace)
+                       .get('language-operator-dashboard-postgresql')
+          rescue K8s::Error::NotFound
+            return { healthy: false, error: 'PostgreSQL service not found' }
+          end
+
+          # Try to connect and authenticate using port-forward and pg_isready
+          require 'open3'
+
+          port = find_available_port
+          pf_pid = nil
+
+          begin
+            # Start port-forward in background
+            pf_command = "kubectl port-forward -n #{@namespace} service/language-operator-dashboard-postgresql #{port}:5432"
+            pf_stdin, pf_stdout, pf_stderr, pf_thread = Open3.popen3(pf_command)
+
+            # Give port-forward time to establish
+            sleep(2)
+
+            # Test connection with pg_isready (if available) or simple TCP connection
+            if system('which pg_isready > /dev/null 2>&1')
+              # Use pg_isready for proper PostgreSQL health check
+              test_output, test_status = Open3.capture2e("pg_isready -h localhost -p #{port} -U postgres -d langop_dashboard")
+              {
+                healthy: test_status.success?,
+                auth_works: test_status.success?,
+                output: test_output.strip
+              }
+            else
+              # Fallback to basic TCP connection test
+              require 'socket'
+              begin
+                socket = TCPSocket.new('localhost', port)
+                socket.close
+                { healthy: true, auth_works: false, note: 'pg_isready not available - basic TCP test only' }
+              rescue StandardError => e
+                { healthy: false, error: e.message }
+              end
+            end
+          rescue StandardError => e
+            { healthy: false, error: e.message }
+          ensure
+            # Clean up port-forward
+            if pf_thread&.alive?
+              Process.kill('TERM', pf_thread.pid) rescue nil
+              pf_thread.join(1)
+            end
+          end
+        end
+
+        # Check if the selected cluster exists in Kubernetes
+        def check_cluster_exists
+          return { healthy: true, note: 'No cluster specified' } unless @cluster_name && @cluster_namespace
+
+          cluster_resource = @k8s.get_resource('LanguageCluster', @cluster_name, @cluster_namespace)
+
+          status = cluster_resource.dig('status', 'phase') || 'Unknown'
+          {
+            healthy: true,
+            status: status,
+            exists: true
+          }
+        rescue K8s::Error::NotFound
+          { healthy: false, error: "Cluster '#{@cluster_name}' not found in namespace '#{@cluster_namespace}'" }
+        rescue StandardError => e
+          { healthy: false, error: e.message }
+        end
+
+        # Run all health checks with progress indicators
+        def run_all_checks
+          results = {}
+
+          # Cluster existence check (first)
+          if @cluster_name && @cluster_namespace
+            begin
+              results[:cluster] = Formatters::ProgressFormatter.with_spinner(
+                "Verifying cluster '#{@cluster_name}' exists"
+              ) { check_cluster_exists }
+            rescue StandardError => e
+              results[:cluster] = { healthy: false, error: e.message }
+            end
+          end
+
+          # Dashboard health check
+          begin
+            results[:dashboard] = Formatters::ProgressFormatter.with_spinner(
+              'Verifying language-operator-dashboard deployment'
+            ) { check_dashboard_health }
+          rescue StandardError => e
+            results[:dashboard] = { healthy: false, error: e.message }
+          end
+
+          # Operator health check  
+          begin
+            results[:operator] = Formatters::ProgressFormatter.with_spinner(
+              'Verifying language-operator deployment'
+            ) { check_operator_health }
+          rescue StandardError => e
+            results[:operator] = { healthy: false, error: e.message }
+          end
+
+          # ClickHouse health check
+          begin
+            results[:clickhouse] = Formatters::ProgressFormatter.with_spinner(
+              'Verifying ClickHouse health and authentication'
+            ) { check_clickhouse_health }
+          rescue StandardError => e
+            results[:clickhouse] = { healthy: false, error: e.message }
+          end
+
+          # PostgreSQL health check
+          begin
+            results[:postgres] = Formatters::ProgressFormatter.with_spinner(
+              'Verifying PostgreSQL health and authentication'
+            ) { check_postgres_health }
+          rescue StandardError => e
+            results[:postgres] = { healthy: false, error: e.message }
+          end
+
+          results
+        end
+
+        private
+
+        # Find an available port for port-forwarding
+        def find_available_port
+          require 'socket'
+          port = 8080
+          begin
+            server = TCPServer.new('localhost', port)
+            port = server.addr[1]
+            server.close
+            port
+          rescue Errno::EADDRINUSE
+            port += 1
+            retry if port < 9000
+            raise 'No available ports found'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/helpers/kubeconfig_validator.rb

@@ -131,8 +131,8 @@ module LanguageOperator
 
               To install the operator:
 
-              1. Using aictl (recommended):
-                 aictl install
+              1. Using langop (recommended):
+                 langop install
 
               2. Or manually with Helm:
                  helm repo add language-operator https://language-operator.github.io/charts
@@ -158,7 +158,7 @@ module LanguageOperator
               3. You have appropriate permissions
 
               For debugging, run with DEBUG=1:
-                DEBUG=1 aictl <command>
+                DEBUG=1 langop <command>
             MSG
           end
         end

data/lib/language_operator/cli/helpers/ux_helper.rb

@@ -433,15 +433,16 @@ module LanguageOperator
         # @param created [String, nil] Creation timestamp (optional)
         # @param domain [String, nil] Cluster domain (optional)
         # @return [void] Displays formatted cluster information
-        def format_cluster_details(name:, namespace:, context:, status: nil, created: nil, domain: nil)
+        def format_cluster_details(name:, namespace:, context:, status: nil, created: nil, domain: nil, org_id: nil)
           format_resource_details(
             type: 'Cluster',
             name: name,
             common_fields: {
-              'Namespace' => namespace,
-              'Context' => context
+              'Namespace' => namespace
             },
             optional_fields: {
+              'Org ID' => org_id,
+              'Context' => context,
               'Domain' => domain,
               'Status' => status,
               'Created' => created

data/lib/language_operator/cli/main.rb

@@ -10,9 +10,10 @@ require_relative 'commands/status'
 require_relative 'commands/persona'
 require_relative 'commands/tool/base'
 require_relative 'commands/model/base'
-require_relative 'commands/quickstart'
 require_relative 'commands/install'
 require_relative 'commands/system/base'
+require_relative 'commands/ui'
+require_relative 'commands/organization'
 require_relative 'formatters/progress_formatter'
 require_relative 'helpers/ux_helper'
 require_relative '../config/cluster_config'
@@ -21,7 +22,7 @@ require_relative 'errors/thor_errors'
 
 module LanguageOperator
   module CLI
-    # Main CLI class for aictl command
+    # Main CLI class for langop command
     #
     # Provides commands for creating, running, and managing language-operator resources.
     class Main < Thor
@@ -36,7 +37,7 @@ module LanguageOperator
         Commands::Status.new.invoke(:overview)
       end
 
-      desc 'version', 'Show aictl and operator version'
+      desc 'version', 'Show langop and operator version'
       def version
         # Check operator installation status first
         current_cluster = Config::ClusterConfig.current_cluster
@@ -71,6 +72,9 @@ module LanguageOperator
       desc 'cluster SUBCOMMAND ...ARGS', 'Manage clusters'
       subcommand 'cluster', Commands::Cluster
 
+      desc 'organization SUBCOMMAND ...ARGS', 'Manage organizations'
+      subcommand 'organization', Commands::Organization
+
       desc 'use CLUSTER', 'Switch to a different cluster'
       def use(cluster_name)
         Commands::Use.new.switch(cluster_name)
@@ -91,9 +95,14 @@ module LanguageOperator
       desc 'system SUBCOMMAND ...ARGS', 'System utilities'
       subcommand 'system', Commands::System::Base
 
-      desc 'quickstart', 'Wizard for first-time users'
-      def quickstart
-        Commands::Quickstart.new.invoke(:start)
+      desc 'ui', 'Open the Language Operator dashboard in your browser'
+      option :port, type: :numeric, default: Commands::Ui::DEFAULT_PORT, desc: "Local port to forward to (default: #{Commands::Ui::DEFAULT_PORT})"
+      option :service, type: :string, default: Commands::Ui::DEFAULT_SERVICE_NAME, desc: "Service name to connect to (default: #{Commands::Ui::DEFAULT_SERVICE_NAME})"
+      option :service_port, type: :numeric, default: Commands::Ui::DEFAULT_SERVICE_PORT, desc: "Service port to forward from (default: #{Commands::Ui::DEFAULT_SERVICE_PORT})"
+      option :namespace, type: :string, default: 'language-operator', desc: 'Namespace to connect to (default: language-operator)'
+      option :no_open, type: :boolean, default: false, desc: 'Do not automatically open browser'
+      def ui
+        Commands::Ui.new([], options).ui
       end
 
       desc 'install', 'Install the language-operator using Helm'
@@ -127,24 +136,24 @@ module LanguageOperator
         Commands::Install.new([], options).uninstall
       end
 
-      desc 'completion SHELL', 'Install shell completion for aictl (bash, zsh, fish)'
+      desc 'completion SHELL', 'Install shell completion for langop (bash, zsh, fish)'
       long_desc <<-DESC
-        Install shell completion for aictl. Supports bash, zsh, and fish.
+        Install shell completion for langop. Supports bash, zsh, and fish.
 
         Examples:
-          aictl completion bash
-          aictl completion zsh
-          aictl completion fish
+          langop completion bash
+          langop completion zsh
+          langop completion fish
 
         Manual installation:
           bash: Add to ~/.bashrc:
-            source <(aictl completion bash --stdout)
+            source <(langop completion bash --stdout)
 
           zsh: Add to ~/.zshrc:
-            source <(aictl completion zsh --stdout)
+            source <(langop completion zsh --stdout)
 
           fish: Run once:
-            aictl completion fish | source
+            langop completion fish | source
       DESC
       option :stdout, type: :boolean, desc: 'Print completion script to stdout instead of installing'
       def completion(shell)
@@ -177,28 +186,28 @@ module LanguageOperator
       private
 
       def install_bash_completion
-        completion_file = File.expand_path('../../completions/aictl.bash', __dir__)
+        completion_file = File.expand_path('../../completions/langop.bash', __dir__)
 
         if options[:stdout]
           puts File.read(completion_file)
           return
         end
 
-        target = LanguageOperator::Utils::SecurePath.expand_home_path('.bash_completion.d/aictl')
+        target = LanguageOperator::Utils::SecurePath.expand_home_path('.bash_completion.d/langop')
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.cp(completion_file, target)
 
         Formatters::ProgressFormatter.success('Bash completion installed')
         puts
         puts 'Add to your ~/.bashrc:'
-        puts '  [ -f ~/.bash_completion.d/aictl ] && source ~/.bash_completion.d/aictl'
+        puts '  [ -f ~/.bash_completion.d/langop ] && source ~/.bash_completion.d/langop'
         puts
         puts 'Then reload your shell:'
         puts '  source ~/.bashrc'
       end
 
       def install_zsh_completion
-        completion_file = File.expand_path('../../completions/_aictl', __dir__)
+        completion_file = File.expand_path('../../completions/_langop', __dir__)
 
         if options[:stdout]
           puts File.read(completion_file)
@@ -209,7 +218,7 @@ module LanguageOperator
         fpath_dir = LanguageOperator::Utils::SecurePath.expand_home_path('.zsh/completions')
         FileUtils.mkdir_p(fpath_dir)
 
-        target = File.join(fpath_dir, '_aictl')
+        target = File.join(fpath_dir, '_langop')
         FileUtils.cp(completion_file, target)
 
         Formatters::ProgressFormatter.success('Zsh completion installed')
@@ -223,14 +232,14 @@ module LanguageOperator
       end
 
       def install_fish_completion
-        completion_file = File.expand_path('../../completions/aictl.fish', __dir__)
+        completion_file = File.expand_path('../../completions/langop.fish', __dir__)
 
         if options[:stdout]
           puts File.read(completion_file)
           return
         end
 
-        target = LanguageOperator::Utils::SecurePath.expand_home_path('.config/fish/completions/aictl.fish')
+        target = LanguageOperator::Utils::SecurePath.expand_home_path('.config/fish/completions/langop.fish')
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.cp(completion_file, target)
 

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

@@ -191,8 +191,8 @@ module LanguageOperator
             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"
+            puts "Use 'langop model inspect #{model_name}' to view details"
+            puts "Use 'langop model edit #{model_name}' to modify it"
             return false
           rescue K8s::Error::NotFound
             # Expected - model doesn't exist yet
@@ -224,7 +224,9 @@ module LanguageOperator
               provider: provider_info[:provider_key],
               model: model_id,
               endpoint: provider_info[:endpoint],
-              cluster: ctx.namespace
+              cluster: ctx.namespace,
+              cluster_ref: ctx.name,
+              k8s_client: ctx.client
             )
 
             # Add API key reference if secret was created
@@ -260,9 +262,9 @@ module LanguageOperator
           puts 'Next steps:'
           puts
           puts '1. Use this model in an agent:'
-          puts "   #{pastel.dim("aictl agent create --model #{model_name}")}"
+          puts "   #{pastel.dim("langop agent create --model #{model_name}")}"
           puts '2. View model details:'
-          puts "   #{pastel.dim("aictl model inspect #{model_name}")}"
+          puts "   #{pastel.dim("langop model inspect #{model_name}")}"
           puts
         end
       end

data/lib/language_operator/config/cluster_config.rb

@@ -6,9 +6,9 @@ require_relative '../utils/secure_path'
 
 module LanguageOperator
   module Config
-    # Manages cluster configuration in ~/.aictl/config.yaml
+    # Manages cluster configuration in ~/.langop/config.yaml
     class ClusterConfig
-      CONFIG_DIR = LanguageOperator::Utils::SecurePath.expand_home_path('.aictl')
+      CONFIG_DIR = LanguageOperator::Utils::SecurePath.expand_home_path('.langop')
       CONFIG_PATH = File.join(CONFIG_DIR, 'config.yaml')
 
       class << self
@@ -90,7 +90,7 @@ module LanguageOperator
 
         def default_config
           {
-            'apiVersion' => 'aictl.langop.io/v1',
+            'apiVersion' => 'langop.langop.io/v1',
             'kind' => 'Config',
             'current-cluster' => nil,
             'clusters' => []

data/lib/language_operator/constants/kubernetes_labels.rb

@@ -13,7 +13,7 @@ module LanguageOperator
 
       # Language Operator specific values
       PROJECT_NAME = 'language-operator'
-      MANAGED_BY_AICTL = 'aictl'
+      MANAGED_BY_AICTL = 'langop'
       COMPONENT_AGENT = 'agent'
       COMPONENT_TEST_AGENT = 'test-agent'