language-operator 0.0.1 → 0.1.30

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

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'yaml'
+require 'pastel'
+require_relative '../formatters/progress_formatter'
+require_relative '../formatters/table_formatter'
+require_relative '../helpers/cluster_validator'
+require_relative '../helpers/cluster_context'
+require_relative '../helpers/user_prompts'
+require_relative '../helpers/resource_dependency_checker'
+require_relative '../helpers/editor_helper'
+require_relative '../../config/cluster_config'
+require_relative '../../kubernetes/client'
+require_relative '../../kubernetes/resource_builder'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      # Persona management commands
+      class Persona < Thor
+        include Helpers::ClusterValidator
+
+        desc 'list', 'List all personas in current cluster'
+        option :cluster, type: :string, desc: 'Override current cluster context'
+        def list
+          ctx = Helpers::ClusterContext.from_options(options)
+
+          personas = ctx.client.list_resources('LanguagePersona', namespace: ctx.namespace)
+
+          if personas.empty?
+            Formatters::ProgressFormatter.info("No personas found in cluster '#{ctx.name}'")
+            puts
+            puts 'Personas define the personality and capabilities of agents.'
+            puts
+            puts 'Create a persona with:'
+            puts '  aictl persona create <name>'
+            return
+          end
+
+          # Get agents to count usage
+          agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+
+          table_data = personas.map do |persona|
+            name = persona.dig('metadata', 'name')
+            used_by = agents.count { |a| a.dig('spec', 'persona') == name }
+
+            {
+              name: name,
+              tone: persona.dig('spec', 'tone') || 'neutral',
+              used_by: used_by,
+              description: persona.dig('spec', 'description') || ''
+            }
+          end
+
+          Formatters::TableFormatter.personas(table_data)
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to list personas: #{e.message}")
+          raise if ENV['DEBUG']
+
+          exit 1
+        end
+
+        desc 'show NAME', 'Display full persona details'
+        option :cluster, type: :string, desc: 'Override current cluster context'
+        def show(name)
+          ctx = Helpers::ClusterContext.from_options(options)
+
+          begin
+            persona = ctx.client.get_resource('LanguagePersona', name, ctx.namespace)
+          rescue K8s::Error::NotFound
+            Formatters::ProgressFormatter.error("Persona '#{name}' not found in cluster '#{ctx.name}'")
+            exit 1
+          end
+
+          puts
+          puts "Persona: #{pastel.cyan.bold(name)}"
+          puts '═' * 80
+          puts
+
+          # Format and display key persona details
+          spec = persona['spec'] || {}
+          puts "#{pastel.bold('Display Name:')} #{spec['displayName']}"
+          puts "#{pastel.bold('Tone:')} #{pastel.yellow(spec['tone'])}" if spec['tone']
+          puts
+          puts pastel.bold('Description:')
+          puts "  #{spec['description']}"
+          puts
+
+          if spec['systemPrompt']
+            puts pastel.bold('System Prompt:')
+            puts "  #{spec['systemPrompt']}"
+            puts
+          end
+
+          if spec['capabilities']&.any?
+            puts pastel.bold('Capabilities:')
+            spec['capabilities'].each do |cap|
+              puts "  #{pastel.green('•')} #{cap}"
+            end
+            puts
+          end
+
+          if spec['toolPreferences']&.any?
+            puts pastel.bold('Tool Preferences:')
+            spec['toolPreferences'].each do |pref|
+              puts "  #{pastel.green('•')} #{pref}"
+            end
+            puts
+          end
+
+          if spec['responseFormat']
+            puts "#{pastel.bold('Response Format:')} #{spec['responseFormat']}"
+            puts
+          end
+
+          puts '═' * 80
+          puts
+          Formatters::ProgressFormatter.info('Use this persona when creating agents:')
+          puts "  aictl agent create \"description\" --persona #{name}"
+          puts
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to show persona: #{e.message}")
+          raise if ENV['DEBUG']
+
+          exit 1
+        end
+
+        desc 'create NAME', 'Create a new persona'
+        long_desc <<-DESC
+          Create a new persona with the specified name using an interactive wizard.
+
+          Examples:
+            aictl persona create helpful-assistant
+            aictl persona create code-reviewer --from helpful-assistant
+        DESC
+        option :cluster, type: :string, desc: 'Override current cluster context'
+        option :from, type: :string, desc: 'Copy from existing persona as starting point'
+        def create(name)
+          ctx = Helpers::ClusterContext.from_options(options)
+
+          # Check if persona already exists
+          begin
+            ctx.client.get_resource('LanguagePersona', name, ctx.namespace)
+            Formatters::ProgressFormatter.error("Persona '#{name}' already exists in cluster '#{ctx.name}'")
+            puts
+            puts 'Use a different name or delete the existing persona first:'
+            puts "  aictl persona delete #{name}"
+            exit 1
+          rescue K8s::Error::NotFound
+            # Good - persona doesn't exist yet
+          end
+
+          # If --from flag provided, copy from existing persona
+          base_persona = nil
+          if options[:from]
+            begin
+              base_persona = ctx.client.get_resource('LanguagePersona', options[:from], ctx.namespace)
+              Formatters::ProgressFormatter.info("Copying from persona '#{options[:from]}'")
+              puts
+            rescue K8s::Error::NotFound
+              Formatters::ProgressFormatter.error("Source persona '#{options[:from]}' not found")
+              exit 1
+            end
+          end
+
+          # Interactive prompts
+          require 'tty-prompt'
+          prompt = TTY::Prompt.new
+
+          puts
+          puts '=' * 80
+          puts '  Create New Persona'
+          puts '=' * 80
+          puts
+
+          # Get display name
+          default_display_name = base_persona&.dig('spec', 'displayName') || name.split('-').map(&:capitalize).join(' ')
+          display_name = prompt.ask('Display Name:', default: default_display_name)
+
+          # Get description
+          default_description = base_persona&.dig('spec', 'description') || ''
+          description = prompt.ask('Description:', default: default_description) do |q|
+            q.required true
+          end
+
+          # Get tone
+          default_tone = base_persona&.dig('spec', 'tone') || 'neutral'
+          tone = prompt.select('Tone:', %w[neutral friendly professional technical creative], default: default_tone)
+
+          # Get system prompt
+          puts
+          puts 'System Prompt (press Enter to open editor):'
+          prompt.keypress('Press any key to continue...')
+
+          default_system_prompt = base_persona&.dig('spec', 'systemPrompt') || ''
+          system_prompt = edit_in_editor(default_system_prompt, 'persona-system-prompt')
+
+          if system_prompt.strip.empty?
+            Formatters::ProgressFormatter.error('System prompt cannot be empty')
+            exit 1
+          end
+
+          # Get capabilities
+          puts
+          puts 'Capabilities (optional, press Enter to open editor, or leave empty to skip):'
+          puts 'Describe what this persona can do, one per line.'
+          prompt.keypress('Press any key to continue...')
+
+          default_capabilities = base_persona&.dig('spec', 'capabilities')&.join("\n") || ''
+          capabilities_text = edit_in_editor(default_capabilities, 'persona-capabilities')
+          capabilities = capabilities_text.strip.empty? ? [] : capabilities_text.strip.split("\n").map(&:strip).reject(&:empty?)
+
+          # Build persona resource
+          persona_spec = {
+            'displayName' => display_name,
+            'description' => description,
+            'tone' => tone,
+            'systemPrompt' => system_prompt.strip
+          }
+          persona_spec['capabilities'] = capabilities unless capabilities.empty?
+
+          persona_resource = Kubernetes::ResourceBuilder.build_persona(
+            name: name,
+            spec: persona_spec,
+            namespace: ctx.namespace
+          )
+
+          # Show preview
+          puts
+          puts '=' * 80
+          puts 'Preview:'
+          puts '=' * 80
+          puts YAML.dump(persona_resource)
+          puts '=' * 80
+          puts
+
+          # Confirm creation
+          unless prompt.yes?('Create this persona?')
+            puts 'Creation cancelled'
+            return
+          end
+
+          # Create persona
+          Formatters::ProgressFormatter.with_spinner("Creating persona '#{name}'") do
+            ctx.client.create_resource(persona_resource)
+          end
+
+          Formatters::ProgressFormatter.success("Persona '#{name}' created successfully")
+          puts
+          puts 'Use this persona when creating agents:'
+          puts "  aictl agent create \"description\" --persona #{name}"
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to create persona: #{e.message}")
+          raise if ENV['DEBUG']
+
+          exit 1
+        end
+
+        desc 'edit NAME', 'Edit an existing persona'
+        long_desc <<-DESC
+          Edit an existing persona by opening the YAML definition in your editor.
+
+          When you save and close the editor, the persona will be updated.
+          Any agents using this persona will be automatically re-synthesized.
+
+          Example:
+            aictl persona edit helpful-assistant
+        DESC
+        option :cluster, type: :string, desc: 'Override current cluster context'
+        def edit(name)
+          ctx = Helpers::ClusterContext.from_options(options)
+
+          # Get current persona
+          begin
+            persona = ctx.client.get_resource('LanguagePersona', name, ctx.namespace)
+          rescue K8s::Error::NotFound
+            Formatters::ProgressFormatter.error("Persona '#{name}' not found in cluster '#{ctx.name}'")
+            exit 1
+          end
+
+          # Open in editor
+          original_yaml = YAML.dump(persona)
+          edited_yaml = edit_in_editor(original_yaml, "persona-#{name}")
+
+          # Check if changed
+          if edited_yaml.strip == original_yaml.strip
+            Formatters::ProgressFormatter.info('No changes made')
+            return
+          end
+
+          # Parse edited YAML
+          begin
+            edited_persona = YAML.safe_load(edited_yaml)
+          rescue Psych::SyntaxError => e
+            Formatters::ProgressFormatter.error("Invalid YAML: #{e.message}")
+            exit 1
+          end
+
+          # Validate structure
+          unless edited_persona.is_a?(Hash) && edited_persona['spec']
+            Formatters::ProgressFormatter.error('Invalid persona structure: missing spec')
+            exit 1
+          end
+
+          # Update persona
+          Formatters::ProgressFormatter.with_spinner("Updating persona '#{name}'") do
+            ctx.client.update_resource(edited_persona)
+          end
+
+          Formatters::ProgressFormatter.success("Persona '#{name}' updated successfully")
+
+          # Check for agents using this persona
+          agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+          agents_using = Helpers::ResourceDependencyChecker.agents_using_persona(agents, name)
+
+          if agents_using.any?
+            puts
+            Formatters::ProgressFormatter.info("#{agents_using.count} agent(s) will be re-synthesized automatically:")
+            agents_using.each do |agent|
+              puts "  - #{agent.dig('metadata', 'name')}"
+            end
+          end
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to edit persona: #{e.message}")
+          raise if ENV['DEBUG']
+
+          exit 1
+        end
+
+        desc 'delete NAME', 'Delete a persona'
+        option :cluster, type: :string, desc: 'Override current cluster context'
+        option :force, type: :boolean, default: false, desc: 'Skip confirmation'
+        def delete(name)
+          ctx = Helpers::ClusterContext.from_options(options)
+
+          # Get persona
+          begin
+            persona = ctx.client.get_resource('LanguagePersona', name, ctx.namespace)
+          rescue K8s::Error::NotFound
+            Formatters::ProgressFormatter.error("Persona '#{name}' not found in cluster '#{ctx.name}'")
+            exit 1
+          end
+
+          # Check for agents using this persona
+          agents = ctx.client.list_resources('LanguageAgent', namespace: ctx.namespace)
+          agents_using = Helpers::ResourceDependencyChecker.agents_using_persona(agents, name)
+
+          if agents_using.any? && !options[:force]
+            Formatters::ProgressFormatter.warn("Persona '#{name}' is in use by #{agents_using.count} agent(s)")
+            puts
+            puts 'Agents using this persona:'
+            agents_using.each do |agent|
+              puts "  - #{agent.dig('metadata', 'name')}"
+            end
+            puts
+            puts 'Delete these agents first, or use --force to delete anyway.'
+            puts
+            return unless Helpers::UserPrompts.confirm('Are you sure?')
+          end
+
+          # Confirm deletion unless --force
+          unless options[:force] || agents_using.any?
+            puts "This will delete persona '#{name}' from cluster '#{ctx.name}':"
+            puts "  Tone:        #{persona.dig('spec', 'tone')}"
+            puts "  Description: #{persona.dig('spec', 'description')}"
+            puts
+            return unless Helpers::UserPrompts.confirm('Are you sure?')
+          end
+
+          # Delete persona
+          Formatters::ProgressFormatter.with_spinner("Deleting persona '#{name}'") do
+            ctx.client.delete_resource('LanguagePersona', name, ctx.namespace)
+          end
+
+          Formatters::ProgressFormatter.success("Persona '#{name}' deleted successfully")
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to delete persona: #{e.message}")
+          raise if ENV['DEBUG']
+
+          exit 1
+        end
+
+        private
+
+        def edit_in_editor(content, filename_prefix)
+          Helpers::EditorHelper.edit_content(content, filename_prefix, '.txt')
+        end
+
+        def pastel
+          @pastel ||= Pastel.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../formatters/progress_formatter'
+require_relative '../wizards/quickstart_wizard'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      # Quickstart wizard for first-time users
+      class Quickstart < Thor
+        desc 'start', 'Interactive setup wizard for first-time users'
+        def start
+          wizard = Wizards::QuickstartWizard.new
+          wizard.run
+        end
+
+        default_task :start
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../formatters/progress_formatter'
+require_relative '../formatters/table_formatter'
+require_relative '../../config/cluster_config'
+require_relative '../../kubernetes/client'
+require_relative '../helpers/cluster_validator'
+
+module LanguageOperator
+  module CLI
+    module Commands
+      # System status and overview command
+      class Status < Thor
+        desc 'overview', 'Show system status and overview'
+        def overview
+          current_cluster = Config::ClusterConfig.current_cluster
+          clusters = Config::ClusterConfig.list_clusters
+
+          pastel = Pastel.new
+
+          # Current cluster context
+          if current_cluster
+            cluster_config = Config::ClusterConfig.get_cluster(current_cluster)
+
+            puts "\nCluster Details"
+            puts '----------------'
+            puts "Name: #{pastel.bold.white(current_cluster)}"
+            puts "Namespace: #{pastel.bold.white(cluster_config[:namespace])}"
+            puts
+
+            # Check cluster health
+            begin
+              k8s = Helpers::ClusterValidator.kubernetes_client(current_cluster)
+
+              # Operator status
+              if k8s.operator_installed?
+                version = k8s.operator_version || 'installed'
+                Formatters::ProgressFormatter.success("Operator: #{version}")
+              else
+                Formatters::ProgressFormatter.error('Operator: not installed')
+                puts
+                puts 'Install the operator with:'
+                puts '  aictl install'
+                puts
+                return
+              end
+
+              # Agent statistics
+              agents = k8s.list_resources('LanguageAgent', namespace: cluster_config[:namespace])
+              agent_stats = categorize_by_status(agents)
+
+              puts
+              puts "Agents (#{agents.count} total):"
+              agent_stats.each do |status, count|
+                puts "  #{format_status(status)}: #{count}"
+              end
+
+              # Tool statistics
+              tools = k8s.list_resources('LanguageTool', namespace: cluster_config[:namespace])
+              puts
+              puts "Tools (#{tools.count} total):"
+              if tools.any?
+                tool_types = tools.group_by { |t| t.dig('spec', 'type') }
+                tool_types.each do |type, items|
+                  puts "  #{type}: #{items.count}"
+                end
+              else
+                puts '  (none)'
+              end
+
+              # Model statistics
+              models = k8s.list_resources('LanguageModel', namespace: cluster_config[:namespace])
+              puts
+              puts "Models (#{models.count} total):"
+              if models.any?
+                model_providers = models.group_by { |m| m.dig('spec', 'provider') }
+                model_providers.each do |provider, items|
+                  puts "  #{provider}: #{items.count}"
+                end
+              else
+                puts '  (none)'
+              end
+
+              # Persona statistics
+              personas = k8s.list_resources('LanguagePersona', namespace: cluster_config[:namespace])
+              puts
+              puts "Personas (#{personas.count} total):"
+              if personas.any?
+                personas.each do |persona|
+                  tone = persona.dig('spec', 'tone')
+                  puts "  - #{persona.dig('metadata', 'name')} (#{tone})"
+                end
+              else
+                puts '  (none)'
+              end
+            rescue StandardError => e
+              Formatters::ProgressFormatter.error("Connection failed: #{e.message}")
+              puts
+              puts 'Check your cluster connection and try again'
+            end
+          else
+            Formatters::ProgressFormatter.warn('No cluster selected')
+            puts
+            if clusters.any?
+              puts 'Available clusters:'
+              clusters.each do |cluster|
+                puts "  - #{cluster[:name]}"
+              end
+              puts
+              puts 'Select a cluster with:'
+              puts '  aictl use <cluster>'
+            else
+              puts 'No clusters found. Create one with:'
+              puts '  aictl cluster create <name>'
+            end
+          end
+
+          puts
+        end
+
+        default_task :overview
+
+        private
+
+        def format_status(status)
+          require 'pastel'
+          pastel = Pastel.new
+
+          status_str = status.to_s
+          case status_str.downcase
+          when 'ready', 'running', 'active'
+            "#{pastel.green('●')} #{status_str}"
+          when 'pending', 'creating', 'synthesizing'
+            "#{pastel.yellow('●')} #{status_str}"
+          when 'failed', 'error'
+            "#{pastel.red('●')} #{status_str}"
+          when 'paused', 'stopped'
+            "#{pastel.dim('●')} #{status_str}"
+          else
+            "#{pastel.dim('●')} #{status_str}"
+          end
+        end
+
+        def categorize_by_status(resources)
+          stats = Hash.new(0)
+          resources.each do |resource|
+            status = resource.dig('status', 'phase') || 'Unknown'
+            stats[status] += 1
+          end
+          stats
+        end
+      end
+    end
+  end
+end