language-operator 0.1.61 → 0.1.62

data/lib/language_operator/cli/commands/tool/base.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+require_relative '../../command_loader'
+require_relative '../../helpers/label_utils'
+
+# Include all tool subcommand modules
+require_relative 'install'
+require_relative 'test'
+require_relative 'search'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Tool
+        # Base tool command class
+        class Base < BaseCommand
+          include Constants
+          include CLI::Helpers::ClusterValidator
+
+          # Include all subcommand modules
+          include Install
+          include Test
+          include Search
+
+          desc 'list', 'List all tools in current cluster'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          def list
+            handle_command_error('list tools') do
+              tools = list_resources_or_empty(RESOURCE_TOOL, resource_name: 'tools') do
+                puts
+                puts 'Install a tool with:'
+                puts '  aictl tool install <name>'
+              end
+
+              return if tools.empty?
+
+              # Get agents to count usage
+              agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
+
+              table_data = tools.map do |tool|
+                name = tool.dig('metadata', 'name')
+                tool.dig('spec', 'type') || 'unknown'
+                status = tool.dig('status', 'phase') || 'Unknown'
+
+                # Count agents using this tool
+                Helpers::ResourceDependencyChecker.tool_usage_count(agents, name)
+
+                # Get health status
+                health = tool.dig('status', 'health') || 'unknown'
+                case health.downcase
+                when 'healthy' then '✓'
+                when 'unhealthy' then '✗'
+                else '?'
+                end
+
+                {
+                  name: name,
+                  namespace: tool.dig('metadata', 'namespace') || ctx.namespace,
+                  status: status
+                }
+              end
+
+              Formatters::TableFormatter.tools(table_data)
+            end
+          end
+
+          desc 'inspect NAME', 'Show detailed tool information'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          def inspect(name)
+            handle_command_error('inspect tool') do
+              tool = get_resource_or_exit(RESOURCE_TOOL, name)
+
+              # Main tool information
+              puts
+              highlighted_box(
+                title: RESOURCE_TOOL,
+                rows: {
+                  'Name' => pastel.white.bold(name),
+                  'Namespace' => ctx.namespace,
+                  'Cluster' => ctx.name,
+                  'Status' => tool.dig('status', 'phase') || 'Unknown',
+                  'Type' => tool.dig('spec', 'type') || 'mcp',
+                  'Image' => tool.dig('spec', 'image'),
+                  'Deployment Mode' => tool.dig('spec', 'deploymentMode') || 'sidecar',
+                  'Port' => tool.dig('spec', 'port') || 8080,
+                  'Replicas' => tool.dig('spec', 'replicas') || 1
+                }
+              )
+              puts
+
+              # Resources
+              resources = tool.dig('spec', 'resources')
+              if resources
+                resource_rows = {}
+                requests = resources['requests'] || {}
+                limits = resources['limits'] || {}
+
+                # CPU
+                cpu_request = requests['cpu']
+                cpu_limit = limits['cpu']
+                resource_rows['CPU'] = [cpu_request, cpu_limit].compact.join(' / ') if cpu_request || cpu_limit
+
+                # Memory
+                memory_request = requests['memory']
+                memory_limit = limits['memory']
+                resource_rows['Memory'] = [memory_request, memory_limit].compact.join(' / ') if memory_request || memory_limit
+
+                highlighted_box(title: 'Resources (Request/Limit)', rows: resource_rows, color: :cyan) unless resource_rows.empty?
+                puts
+              end
+
+              # RBAC
+              rbac = tool.dig('spec', 'rbac')
+              if rbac && rbac['clusterRole']
+                rules = rbac.dig('clusterRole', 'rules') || []
+                puts "RBAC Permissions (#{rules.length} rules):"
+                rules.each_with_index do |rule, idx|
+                  puts "  Rule #{idx + 1}:"
+                  puts "    API Groups: #{rule['apiGroups'].join(', ')}"
+                  puts "    Resources:  #{rule['resources'].join(', ')}"
+                  puts "    Verbs:      #{rule['verbs'].join(', ')}"
+                end
+                puts
+              end
+
+              # Egress rules
+              egress = tool.dig('spec', 'egress') || []
+              if egress.any?
+                puts "Network Egress (#{egress.length} rules):"
+                egress.each_with_index do |rule, idx|
+                  puts "  Rule #{idx + 1}: #{rule['description']}"
+                  puts "    DNS:   #{rule['dns'].join(', ')}" if rule['dns']
+                  puts "    CIDR:  #{rule['cidr']}" if rule['cidr']
+                  if rule['ports']
+                    ports_str = rule['ports'].map { |p| "#{p['port']}/#{p['protocol']}" }.join(', ')
+                    puts "    Ports: #{ports_str}"
+                  end
+                end
+                puts
+              end
+
+              # Try to fetch MCP capabilities
+              capabilities = fetch_mcp_capabilities(name, tool, ctx.namespace)
+              if capabilities && capabilities['tools'] && capabilities['tools'].any?
+                puts "MCP Tools (#{capabilities['tools'].length}):"
+                capabilities['tools'].each_with_index do |mcp_tool, idx|
+                  tool_name = mcp_tool['name']
+
+                  # Generate a meaningful name if empty
+                  if tool_name.nil? || tool_name.empty?
+                    # Try to derive from description (first few words)
+                    if mcp_tool['description']
+                      # Take first 3-4 words and convert to snake_case
+                      words = mcp_tool['description'].split(/\s+/).first(4)
+                      derived_name = words.join('_').downcase.gsub(/[^a-z0-9_]/, '')
+                      tool_name = "#{name}_#{derived_name}".gsub(/__+/, '_').sub(/_$/, '')
+                    else
+                      tool_name = "#{name}_tool_#{idx + 1}"
+                    end
+                  end
+
+                  puts "  #{tool_name}"
+                  puts "    Description: #{mcp_tool['description']}" if mcp_tool['description']
+                  next unless mcp_tool['inputSchema'] && mcp_tool['inputSchema']['properties']
+
+                  params = mcp_tool['inputSchema']['properties'].keys
+                  required = mcp_tool['inputSchema']['required'] || []
+                  param_list = params.map { |p| required.include?(p) ? "#{p}*" : p }
+                  puts "    Parameters:  #{param_list.join(', ')}"
+                end
+                puts '    (* = required)'
+                puts
+              end
+
+              # Get agents using this tool
+              agents = ctx.client.list_resources(RESOURCE_AGENT, namespace: ctx.namespace)
+              agents_using = agents.select do |agent|
+                tools = agent.dig('spec', 'tools') || []
+                tools.include?(name)
+              end
+              agent_names = agents_using.map { |agent| agent.dig('metadata', 'name') }
+
+              list_box(
+                title: 'Agents using this tool',
+                items: agent_names
+              )
+
+              puts
+              labels = tool.dig('metadata', 'labels') || {}
+              list_box(
+                title: 'Labels',
+                items: labels,
+                style: :key_value
+              )
+            end
+          end
+
+          desc 'delete NAME', 'Delete a tool'
+          option :cluster, type: :string, desc: 'Override current cluster context'
+          option :force, type: :boolean, default: false, desc: 'Skip confirmation'
+          def delete(name)
+            handle_command_error('delete tool') do
+              get_resource_or_exit(RESOURCE_TOOL, name)
+
+              # Check dependencies and get confirmation
+              return unless check_dependencies_and_confirm('tool', name, force: options[:force])
+
+              # Confirm deletion unless --force
+              return unless confirm_deletion_with_force('tool', name, ctx.name, force: options[:force])
+
+              # Delete tool
+              Formatters::ProgressFormatter.with_spinner("Deleting tool '#{name}'") do
+                ctx.client.delete_resource(RESOURCE_TOOL, name, ctx.namespace)
+              end
+            end
+          end
+
+          private
+
+          # Fetch MCP capabilities from a running tool server
+          #
+          # @param name [String] Tool name
+          # @param tool [Hash] Tool resource
+          # @param namespace [String] Kubernetes namespace
+          # @return [Hash, nil] MCP capabilities or nil if unavailable
+          def fetch_mcp_capabilities(name, tool, namespace)
+            return nil unless tool.dig('status', 'phase') == 'Running'
+
+            # Get the service endpoint
+            port = tool.dig('spec', 'port') || 80
+
+            # Try to query the MCP server using kubectl port-forward
+            # This is a fallback approach since we can't directly connect from CLI
+            begin
+              # Try to find a pod for this tool
+              label_selector = CLI::Helpers::LabelUtils.agent_pod_selector(name)
+              pods = ctx.client.list_resources('Pod', namespace: namespace, label_selector: label_selector)
+
+              return nil if pods.empty?
+
+              pod_name = pods.first.dig('metadata', 'name')
+
+              # Query the MCP server using JSON-RPC protocol
+              # MCP uses the tools/list method to list available tools
+              json_rpc_request = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/list',
+                params: {}
+              }.to_json
+
+              result = `kubectl exec -n #{namespace} #{pod_name} -- curl -s -X POST \
+http://localhost:#{port}/mcp/tools/list -H "Content-Type: application/json" \
+-d '#{json_rpc_request}' 2>/dev/null`
+
+              return nil if result.empty?
+
+              response = JSON.parse(result)
+              response['result']
+            rescue StandardError
+              # Silently fail - capabilities are optional information
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/tool/install.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'erb'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Tool
+        # Tool installation and authentication commands
+        module Install
+          def self.included(base)
+            base.class_eval do
+              desc 'install NAME', 'Install a tool from the registry'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              option :deployment_mode, type: :string, enum: %w[service sidecar], desc: 'Deployment mode (service or sidecar)'
+              option :replicas, type: :numeric, desc: 'Number of replicas'
+              option :dry_run, type: :boolean, default: false, desc: 'Preview without installing'
+              def install(tool_name)
+                handle_command_error('install tool') do
+                  # For dry-run mode, allow operation without a real cluster
+                  if options[:dry_run]
+                    cluster_name = options[:cluster] || 'preview'
+                    namespace = 'default'
+                  else
+                    cluster_name = ctx.name
+                    namespace = ctx.namespace
+                  end
+
+                  # Load tool patterns registry
+                  registry = Config::ToolRegistry.new
+                  patterns = registry.fetch
+
+                  # Resolve aliases
+                  tool_key = tool_name
+                  tool_key = patterns[tool_key]['alias'] while patterns[tool_key]&.key?('alias')
+
+                  # Look up tool in registry
+                  tool_config = patterns[tool_key]
+                  unless tool_config
+                    Formatters::ProgressFormatter.error("Tool '#{tool_name}' not found in registry")
+                    puts
+                    puts 'Available tools:'
+                    patterns.each do |key, config|
+                      next if config['alias']
+
+                      puts "  #{key.ljust(15)} - #{config['description']}"
+                    end
+                    exit 1
+                  end
+
+                  # Build template variables
+                  vars = {
+                    name: tool_name,
+                    namespace: namespace,
+                    cluster_ref: cluster_name,
+                    deployment_mode: options[:deployment_mode] || tool_config['deploymentMode'],
+                    replicas: options[:replicas] || 1,
+                    auth_secret: nil, # Will be set by auth command
+                    image: tool_config['image'],
+                    port: tool_config['port'],
+                    type: tool_config['type'],
+                    egress: tool_config['egress'],
+                    rbac: tool_config['rbac']
+                  }
+
+                  # Get template content - prefer registry manifest, fall back to generic template
+                  if tool_config['manifest']
+                    # Use manifest from registry (if provided in the future)
+                    template_content = tool_config['manifest']
+                  else
+                    # Use generic template for all tools
+                    template_path = File.join(__dir__, '..', '..', 'templates', 'tools', 'generic.yaml')
+                    template_content = File.read(template_path)
+                  end
+
+                  # Render template
+                  template = ERB.new(template_content, trim_mode: '-')
+                  yaml_content = template.result_with_hash(vars)
+
+                  # Dry run mode
+                  if options[:dry_run]
+                    puts "Would install tool '#{tool_name}' to cluster '#{cluster_name}':"
+                    puts
+                    puts "Display Name:    #{tool_config['displayName']}"
+                    puts "Description:     #{tool_config['description']}"
+                    puts "Deployment Mode: #{vars[:deployment_mode]}"
+                    puts "Replicas:        #{vars[:replicas]}"
+                    puts "Auth Required:   #{tool_config['authRequired'] ? 'Yes' : 'No'}"
+                    puts
+                    puts 'Generated YAML:'
+                    puts '---'
+                    puts yaml_content
+                    puts
+                    puts 'To install for real, run without --dry-run'
+                    return
+                  end
+
+                  # Check if already exists
+                  begin
+                    ctx.client.get_resource(LanguageOperator::Constants::RESOURCE_TOOL, tool_name, ctx.namespace)
+                    Formatters::ProgressFormatter.warn("Tool '#{tool_name}' already exists in cluster '#{ctx.name}'")
+                    puts
+                    return unless CLI::Helpers::UserPrompts.confirm('Do you want to update it?')
+                  rescue K8s::Error::NotFound
+                    # Tool doesn't exist, proceed with creation
+                  end
+
+                  # Install tool
+                  Formatters::ProgressFormatter.with_spinner("Installing tool '#{tool_name}'") do
+                    resource = YAML.safe_load(yaml_content, permitted_classes: [Symbol])
+                    ctx.client.apply_resource(resource)
+                  end
+
+                  puts
+
+                  # Show tool details
+                  format_tool_details(
+                    name: tool_name,
+                    namespace: ctx.namespace,
+                    cluster: ctx.name,
+                    status: 'Ready',
+                    image: tool_config['image'],
+                    created: Time.now.strftime('%Y-%m-%dT%H:%M:%SZ')
+                  )
+
+                  puts
+                  if tool_config['authRequired']
+                    puts 'This tool requires authentication. Configure it with:'
+                    puts pastel.dim("  aictl tool auth #{tool_name}")
+                  else
+                    puts "Tool '#{tool_name}' is now available for agents to use"
+                  end
+                end
+              end
+
+              desc 'auth NAME', 'Configure authentication for a tool'
+              option :cluster, type: :string, desc: 'Override current cluster context'
+              def auth(tool_name)
+                handle_command_error('configure auth') do
+                  tool = get_resource_or_exit(LanguageOperator::Constants::RESOURCE_TOOL, tool_name,
+                                              error_message: "Tool '#{tool_name}' not found. Install it first with: aictl tool install #{tool_name}")
+
+                  puts "Configure authentication for tool '#{tool_name}'"
+                  puts
+
+                  # Determine auth type based on tool
+                  case tool_name
+                  when 'email', 'gmail'
+                    puts 'Email/Gmail Configuration'
+                    puts '-' * 40
+                    print 'SMTP Server: '
+                    smtp_server = $stdin.gets.chomp
+                    print 'SMTP Port (587): '
+                    smtp_port = $stdin.gets.chomp
+                    smtp_port = '587' if smtp_port.empty?
+                    print 'Email Address: '
+                    email = $stdin.gets.chomp
+                    print 'Password: '
+                    password = $stdin.noecho(&:gets).chomp
+                    puts
+
+                    secret_data = {
+                      'SMTP_SERVER' => smtp_server,
+                      'SMTP_PORT' => smtp_port,
+                      'EMAIL_ADDRESS' => email,
+                      'EMAIL_PASSWORD' => password
+                    }
+
+                  when 'github'
+                    puts 'GitHub Configuration'
+                    puts '-' * 40
+                    print 'GitHub Token: '
+                    token = $stdin.noecho(&:gets).chomp
+                    puts
+
+                    secret_data = {
+                      'GITHUB_TOKEN' => token
+                    }
+
+                  when 'slack'
+                    puts 'Slack Configuration'
+                    puts '-' * 40
+                    print 'Slack Bot Token: '
+                    token = $stdin.noecho(&:gets).chomp
+                    puts
+
+                    secret_data = {
+                      'SLACK_BOT_TOKEN' => token
+                    }
+
+                  when 'gdrive'
+                    puts 'Google Drive Configuration'
+                    puts '-' * 40
+                    puts 'Note: You need OAuth credentials from Google Cloud Console'
+                    print 'Client ID: '
+                    client_id = $stdin.gets.chomp
+                    print 'Client Secret: '
+                    client_secret = $stdin.noecho(&:gets).chomp
+                    puts
+
+                    secret_data = {
+                      'GDRIVE_CLIENT_ID' => client_id,
+                      'GDRIVE_CLIENT_SECRET' => client_secret
+                    }
+
+                  else
+                    puts 'Generic API Key Configuration'
+                    puts '-' * 40
+                    print 'API Key: '
+                    api_key = $stdin.noecho(&:gets).chomp
+                    puts
+
+                    secret_data = {
+                      'API_KEY' => api_key
+                    }
+                  end
+
+                  # Create secret
+                  secret_name = "#{tool_name}-auth"
+                  secret_resource = {
+                    'apiVersion' => 'v1',
+                    'kind' => 'Secret',
+                    'metadata' => {
+                      'name' => secret_name,
+                      'namespace' => ctx.namespace
+                    },
+                    'type' => 'Opaque',
+                    'stringData' => secret_data
+                  }
+
+                  Formatters::ProgressFormatter.with_spinner('Creating authentication secret') do
+                    ctx.client.apply_resource(secret_resource)
+                  end
+
+                  # Update tool to use secret
+                  tool['spec']['envFrom'] ||= []
+                  tool['spec']['envFrom'] << { 'secretRef' => { 'name' => secret_name } }
+
+                  Formatters::ProgressFormatter.with_spinner('Updating tool configuration') do
+                    ctx.client.apply_resource(tool)
+                  end
+
+                  Formatters::ProgressFormatter.success('Authentication configured successfully')
+                  puts
+                  puts "Tool '#{tool_name}' is now authenticated and ready to use"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/cli/commands/tool/search.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../../../config/tool_registry'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      module Tool
+        # Tool search commands
+        module Search
+          def self.included(base)
+            base.class_eval do
+              desc 'search [PATTERN]', 'Search available tools in the registry'
+              long_desc <<-DESC
+                Search and list available tools from the registry.
+
+                Without a pattern, lists all available tools.
+                With a pattern, filters tools by name or description (case-insensitive).
+
+                Examples:
+                  aictl tool search              # List all tools
+                  aictl tool search web          # Find tools matching "web"
+                  aictl tool search email        # Find tools matching "email"
+              DESC
+              def search(pattern = nil)
+                handle_command_error('search tools') do
+                  # Load tool patterns registry
+                  registry = Config::ToolRegistry.new
+                  patterns = registry.fetch
+
+                  # Filter out aliases and match pattern
+                  tools = patterns.select do |key, config|
+                    next false if config['alias'] # Skip aliases
+
+                    if pattern
+                      # Case-insensitive match on name or description
+                      key.downcase.include?(pattern.downcase) ||
+                        config['description']&.downcase&.include?(pattern.downcase)
+                    else
+                      true
+                    end
+                  end
+
+                  if tools.empty?
+                    if pattern
+                      Formatters::ProgressFormatter.info("No tools found matching '#{pattern}'")
+                    else
+                      Formatters::ProgressFormatter.info('No tools found in registry')
+                    end
+                    return
+                  end
+
+                  # Display tools in a nice format
+                  tools.each do |name, config|
+                    description = config['description'] || 'No description'
+
+                    # Bold the tool name (ANSI escape codes)
+                    bold_name = "\e[1m#{name}\e[0m"
+                    puts "#{bold_name} - #{description}"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end