language-operator 0.1.81 → 0.1.82

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative '../base_command'
+require_relative '../formatters/progress_formatter'
+require_relative '../../kubernetes/client'
+require_relative '../helpers/cluster_validator'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      # UI command to open the Language Operator dashboard in browser
+      class Ui < BaseCommand
+        DEFAULT_PORT = 8080
+        DEFAULT_SERVICE_NAME = 'language-operator-dashboard'
+        DEFAULT_SERVICE_PORT = 3000
+
+        desc 'ui', 'Open the Language Operator dashboard in your browser'
+        long_desc <<-DESC
+          Opens the Language Operator dashboard in your default browser.
+
+          This command will:
+          1. Set up a port forward to the dashboard service
+          2. Open your default browser to the dashboard URL
+          3. Keep the port forward running until you stop it (Ctrl+C)
+
+          The dashboard provides a web interface for managing agents, tools, models, and monitoring
+          the Language Operator cluster.
+
+          Examples:
+            # Open dashboard with default settings
+            langop ui
+
+            # Use a specific local port
+            langop ui --port 9090
+
+            # Connect to a specific service
+            langop ui --service my-dashboard --service-port 8080
+        DESC
+        option :port, type: :numeric, default: DEFAULT_PORT, desc: "Local port to forward to (default: #{DEFAULT_PORT})"
+        option :service, type: :string, default: DEFAULT_SERVICE_NAME, desc: "Service name to connect to (default: #{DEFAULT_SERVICE_NAME})"
+        option :service_port, type: :numeric, default: DEFAULT_SERVICE_PORT, desc: "Service port to forward from (default: #{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
+          handle_command_error('open dashboard') do
+
+            logo(title: 'open dashboard')
+
+            # Check if operator is installed and get service info
+            validate_operator_installation
+
+            port = options[:port]
+            service_name = options[:service]
+            service_port = options[:service_port]
+
+            # Start port forward in background
+            port_forward_pid = start_port_forward(service_name, service_port, port)
+
+            # Wait a moment for port forward to establish
+            sleep 2
+
+            # Open browser unless --no-open
+            open_browser("http://localhost:#{port}") unless options[:no_open]
+
+            puts
+            puts 'If your browser was not opened automatically, your dashboard is at:'
+            puts pastel.white.bold("http://localhost:#{port}")
+            puts
+            puts 'Press Ctrl+C to stop the port forward and exit'
+
+            # Handle graceful shutdown
+            trap('INT') do
+              puts "\nStopping port forward..."
+              stop_port_forward(port_forward_pid)
+              puts 'Dashboard closed.'
+              exit 0
+            end
+
+            # Keep the process running
+            loop do
+              sleep 1
+            end
+          end
+        end
+
+        private
+
+        def validate_operator_installation
+          namespace = options[:namespace]
+          
+          # Use current kubectl context directly
+          k8s = Kubernetes::Client.new
+
+          # Check if the operator namespace exists
+          unless k8s.namespace_exists?(namespace)
+            Formatters::ProgressFormatter.error("Namespace '#{namespace}' not found")
+            puts
+            puts 'The Language Operator does not appear to be installed.'
+            puts 'Install it with: langop install'
+            exit 1
+          end
+
+          # Check if the dashboard service exists
+          begin
+            k8s.get_resource('Service', options[:service], namespace)
+          rescue StandardError
+            Formatters::ProgressFormatter.error("Dashboard service '#{options[:service]}' not found")
+            puts
+            puts 'The dashboard service is not available. This may mean:'
+            puts '  - The Language Operator is not fully deployed'
+            puts '  - The dashboard is disabled in your installation'
+            puts '  - You specified an incorrect service name'
+            puts
+            puts 'Check your installation with: langop status'
+            exit 1
+          end
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to validate installation: #{e.message}")
+          exit 1
+        end
+
+        def start_port_forward(service_name, service_port, local_port)
+          namespace = options[:namespace]
+          cmd = "kubectl port-forward -n #{namespace} service/#{service_name} #{local_port}:#{service_port}"
+
+          Formatters::ProgressFormatter.with_spinner('Setting up port forward') do
+            # Start kubectl port-forward in background
+            pid = Process.spawn(cmd, out: '/dev/null', err: '/dev/null')
+            Process.detach(pid)
+            pid
+          end
+        end
+
+        def stop_port_forward(pid)
+          Process.kill('TERM', pid)
+          # Give it a moment to clean up
+          sleep 1
+          # Force kill if still running
+          Process.kill('KILL', pid) if process_running?(pid)
+        rescue Errno::ESRCH
+          # Process already dead, that's fine
+        end
+
+        def process_running?(pid)
+          Process.getpgid(pid)
+          true
+        rescue Errno::ESRCH
+          false
+        end
+
+        def open_browser(url)
+          # Detect platform and open browser accordingly
+          case RbConfig::CONFIG['host_os']
+          when /mswin|mingw|cygwin/
+            system("start #{url}")
+          when /darwin/
+            system("open #{url}")
+          when /linux|bsd/
+            # Try common Linux browsers
+            browsers = %w[xdg-open google-chrome firefox chromium-browser]
+            browser_found = browsers.any? do |browser|
+              system("which #{browser} > /dev/null 2>&1") && system("#{browser} #{url} > /dev/null 2>&1 &")
+            end
+
+            puts "Could not detect a browser to open. Please manually visit: #{url}" unless browser_found
+          else
+            puts "Unknown platform. Please manually visit: #{url}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,7 @@ require_relative '../base_command'
 require_relative '../formatters/progress_formatter'
 require_relative '../../config/cluster_config'
 require_relative '../helpers/cluster_validator'
+require_relative '../../utils/secure_path'
 
 module LanguageOperator
   module CLI
@@ -19,18 +20,25 @@ module LanguageOperator
 
         def switch(cluster_name)
           handle_command_error('switch cluster') do
-            unless Config::ClusterConfig.cluster_exists?(cluster_name)
-              Formatters::ProgressFormatter.error("Cluster '#{cluster_name}' not found")
-              puts "\nAvailable clusters:"
-              Config::ClusterConfig.list_clusters.each do |cluster|
-                puts "  - #{cluster[:name]}"
+            # First check if cluster exists in local config
+            if Config::ClusterConfig.cluster_exists?(cluster_name)
+              Config::ClusterConfig.set_current_cluster(cluster_name)
+              cluster = Config::ClusterConfig.get_cluster(cluster_name)
+            else
+              # If not in local config, check if it exists in Kubernetes
+              k8s_cluster = find_cluster_in_kubernetes(cluster_name)
+              
+              if k8s_cluster
+                # Auto-import the cluster to local config with current kubectl context
+                import_cluster_to_config(k8s_cluster)
+                Config::ClusterConfig.set_current_cluster(cluster_name)
+                cluster = Config::ClusterConfig.get_cluster(cluster_name)
+              else
+                show_cluster_not_found_error(cluster_name)
+                exit 1
               end
-              exit 1
             end
 
-            Config::ClusterConfig.set_current_cluster(cluster_name)
-            cluster = Config::ClusterConfig.get_cluster(cluster_name)
-
             Formatters::ProgressFormatter.success("Switched to cluster '#{cluster_name}'")
 
             # Get cluster details from Kubernetes for complete information
@@ -61,6 +69,69 @@ module LanguageOperator
             end
           end
         end
+
+        private
+
+        def find_cluster_in_kubernetes(cluster_name)
+          require_relative '../../kubernetes/client'
+          
+          k8s = Kubernetes::Client.new
+          language_clusters = k8s.list_resources('LanguageCluster', namespace: nil)
+          
+          language_clusters.find { |cluster| cluster.dig('metadata', 'name') == cluster_name }
+        rescue StandardError => e
+          # If we can't query Kubernetes, return nil
+          warn "Warning: Could not query Kubernetes: #{e.message}" if ENV['DEBUG']
+          nil
+        end
+
+        def import_cluster_to_config(k8s_cluster)
+          name = k8s_cluster.dig('metadata', 'name')
+          namespace = k8s_cluster.dig('metadata', 'namespace')
+          
+          # Use current kubectl context and config
+          kubeconfig = ENV.fetch('KUBECONFIG', LanguageOperator::Utils::SecurePath.expand_home_path('.kube/config'))
+          
+          require_relative '../../kubernetes/client'
+          k8s_client = Kubernetes::Client.new
+          current_context = k8s_client.current_context
+          
+          
+          Config::ClusterConfig.add_cluster(
+            name,
+            namespace,
+            kubeconfig,
+            current_context
+          )
+        end
+
+        def show_cluster_not_found_error(cluster_name)
+          Formatters::ProgressFormatter.error("Cluster '#{cluster_name}' not found")
+          
+          # Show clusters from both local config and Kubernetes
+          local_clusters = Config::ClusterConfig.list_clusters
+          
+          require_relative '../../kubernetes/client'
+          begin
+            k8s = Kubernetes::Client.new
+            k8s_clusters = k8s.list_resources('LanguageCluster', namespace: nil)
+            k8s_cluster_names = k8s_clusters.map { |c| c.dig('metadata', 'name') }
+          rescue StandardError
+            k8s_cluster_names = []
+          end
+          
+          all_cluster_names = (local_clusters.map { |c| c[:name] } + k8s_cluster_names).uniq
+          
+          if all_cluster_names.any?
+            puts "\nAvailable clusters:"
+            all_cluster_names.each do |name|
+              puts "  - #{name}"
+            end
+          else
+            puts "\nNo clusters found. Create one with:"
+            puts "  langop cluster create <name>"
+          end
+        end
       end
     end
   end

data/lib/language_operator/cli/errors/suggestions.rb

@@ -50,9 +50,9 @@ module LanguageOperator
 
           def agent_not_found_suggestions(context)
             suggestions = []
-            suggestions << "List all agents: #{pastel.dim('aictl agent list')}"
-            suggestions << "Create a new agent: #{pastel.dim('aictl agent create "description"')}"
-            suggestions << "Use the wizard: #{pastel.dim('aictl agent create --wizard')}" if context[:suggest_wizard]
+            suggestions << "List all agents: #{pastel.dim('langop agent list')}"
+            suggestions << "Create a new agent: #{pastel.dim('langop agent create "description"')}"
+            suggestions << "Use the wizard: #{pastel.dim('langop agent create --wizard')}" if context[:suggest_wizard]
             suggestions
           end
 
@@ -61,45 +61,45 @@ module LanguageOperator
             tool_name = context[:tool_name]
 
             if tool_name
-              suggestions << "Install from registry: #{pastel.dim("aictl tool install #{tool_name}")}"
-              suggestions << "Search for tools: #{pastel.dim('aictl tool search')}"
+              suggestions << "Install from registry: #{pastel.dim("langop tool install #{tool_name}")}"
+              suggestions << "Search for tools: #{pastel.dim('langop tool search')}"
             end
 
-            suggestions << "List installed tools: #{pastel.dim('aictl tool list')}"
+            suggestions << "List installed tools: #{pastel.dim('langop tool list')}"
             suggestions
           end
 
           def model_not_found_suggestions(_context)
             suggestions = []
-            suggestions << "List all models: #{pastel.dim('aictl model list')}"
-            suggestions << "Create a new model: #{pastel.dim('aictl model create <name> --provider <provider>')}"
+            suggestions << "List all models: #{pastel.dim('langop model list')}"
+            suggestions << "Create a new model: #{pastel.dim('langop model create <name> --provider <provider>')}"
             suggestions
           end
 
           def persona_not_found_suggestions(_context)
             suggestions = []
-            suggestions << "List all personas: #{pastel.dim('aictl persona list')}"
-            suggestions << "Create a new persona: #{pastel.dim('aictl persona create <name>')}"
+            suggestions << "List all personas: #{pastel.dim('langop persona list')}"
+            suggestions << "Create a new persona: #{pastel.dim('langop persona create <name>')}"
             suggestions
           end
 
           def cluster_not_found_suggestions(_context)
             suggestions = []
-            suggestions << "List available clusters: #{pastel.dim('aictl cluster list')}"
-            suggestions << "Create a new cluster: #{pastel.dim('aictl cluster create <name>')}"
+            suggestions << "List available clusters: #{pastel.dim('langop cluster list')}"
+            suggestions << "Create a new cluster: #{pastel.dim('langop cluster create <name>')}"
             suggestions
           end
 
           def no_cluster_selected_suggestions
             [
               'Create a new cluster:',
-              "  #{pastel.dim('aictl cluster create my-cluster')}",
+              "  #{pastel.dim('langop cluster create my-cluster')}",
               '',
               'Or select an existing cluster:',
-              "  #{pastel.dim('aictl use my-cluster')}",
+              "  #{pastel.dim('langop use my-cluster')}",
               '',
               'List available clusters:',
-              "  #{pastel.dim('aictl cluster list')}"
+              "  #{pastel.dim('langop cluster list')}"
             ]
           end
 
@@ -109,20 +109,20 @@ module LanguageOperator
 
             if cluster
               suggestions << "Create a model in cluster '#{cluster}':"
-              suggestions << "  #{pastel.dim('aictl model create <name> --provider anthropic --model claude-3-5-sonnet')}"
+              suggestions << "  #{pastel.dim('langop model create <name> --provider anthropic --model claude-3-5-sonnet')}"
             else
-              suggestions << "Create a model: #{pastel.dim('aictl model create <name> --provider <provider>')}"
+              suggestions << "Create a model: #{pastel.dim('langop model create <name> --provider <provider>')}"
             end
 
             suggestions << ''
-            suggestions << "List available models: #{pastel.dim('aictl model list')}"
+            suggestions << "List available models: #{pastel.dim('langop model list')}"
             suggestions
           end
 
           def synthesis_failed_suggestions
             [
               'The description may be too vague. Try the interactive wizard:',
-              "  #{pastel.dim('aictl agent create --wizard')}",
+              "  #{pastel.dim('langop agent create --wizard')}",
               '',
               'Or provide a more detailed description with:',
               '  • What the agent should do specifically',
@@ -143,8 +143,8 @@ module LanguageOperator
             suggestions = []
 
             if resource_name
-              suggestions << "View existing #{resource_type}: #{pastel.dim("aictl #{command_for_resource(resource_type)} inspect #{resource_name}")}"
-              suggestions << "Delete and recreate: #{pastel.dim("aictl #{command_for_resource(resource_type)} delete #{resource_name}")}"
+              suggestions << "View existing #{resource_type}: #{pastel.dim("langop #{command_for_resource(resource_type)} inspect #{resource_name}")}"
+              suggestions << "Delete and recreate: #{pastel.dim("langop #{command_for_resource(resource_type)} delete #{resource_name}")}"
             end
 
             suggestions << 'Choose a different name'

data/lib/language_operator/cli/formatters/progress_formatter.rb

@@ -28,7 +28,8 @@ module LanguageOperator
           end
 
           def success(message)
-            puts LogStyle.format(:success, message, pastel)
+            icon = LogStyle.styled_icon(:success, pastel)
+            puts "#{icon} #{message}"
           end
 
           def error(message)

data/lib/language_operator/cli/formatters/table_formatter.rb

@@ -14,7 +14,7 @@ module LanguageOperator
           def clusters(clusters)
             return ProgressFormatter.info('No clusters found') if clusters.empty?
 
-            headers = ['', 'NAME', 'NAMESPACE', 'STATUS', 'DOMAIN']
+            headers = ['', 'NAME', 'NAMESPACE', 'ORGANIZATION', 'STATUS', 'DOMAIN']
             rows = clusters.map do |cluster|
               # Extract asterisk for selected cluster
               name = cluster[:name].to_s.gsub(' *', '')
@@ -33,10 +33,14 @@ module LanguageOperator
                                  cluster[:domain]
                                end
 
+              # Format organization display
+              org_display = cluster[:organization] || 'legacy'
+
               [
                 StatusFormatter.dot(cluster[:status] || 'Unknown'),
                 formatted_name,
                 cluster[:namespace],
+                org_display,
                 cluster[:status] || 'Unknown',
                 domain_display
               ]
@@ -160,6 +164,22 @@ module LanguageOperator
             puts '* = current cluster'
           end
 
+          def organizations(organizations)
+            return ProgressFormatter.info('No organizations found') if organizations.empty?
+
+            headers = ['NAMESPACE', 'ORGANIZATION ID', 'PLAN', 'CREATED']
+            rows = organizations.map do |org|
+              [
+                org[:namespace],
+                org[:organization_id],
+                org[:plan],
+                org[:created]
+              ]
+            end
+
+            puts table(headers, rows)
+          end
+
           private
 
           def truncate(text, length)

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

@@ -77,9 +77,9 @@ module LanguageOperator
             puts 'The kubeconfig file for this cluster does not exist.'
             puts
             puts 'To fix this issue:'
-            puts '  1. Verify the kubeconfig path in ~/.aictl/config.yaml'
+            puts '  1. Verify the kubeconfig path in ~/.langop/config.yaml'
             puts '  2. Re-create the cluster configuration:'
-            puts "     aictl cluster create #{cluster_config[:name]}"
+            puts "     langop cluster create #{cluster_config[:name]}"
             exit 1
           end