language-operator 0.0.1 → 0.1.31

data/lib/language_operator/cli/main.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'fileutils'
+require_relative 'commands/cluster'
+require_relative 'commands/use'
+require_relative 'commands/agent'
+require_relative 'commands/status'
+require_relative 'commands/persona'
+require_relative 'commands/tool'
+require_relative 'commands/model'
+require_relative 'commands/quickstart'
+require_relative 'commands/install'
+require_relative 'commands/system'
+require_relative 'formatters/progress_formatter'
+require_relative '../config/cluster_config'
+require_relative '../kubernetes/client'
+
+module LanguageOperator
+  module CLI
+    # Main CLI class for aictl command
+    #
+    # Provides commands for creating, running, and managing language-operator resources.
+    class Main < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'status', 'Show system status and overview'
+      def status
+        Commands::Status.new.invoke(:overview)
+      end
+
+      desc 'version', 'Show aictl and operator version'
+      def version
+        puts "aictl v#{LanguageOperator::VERSION}"
+        puts
+
+        # Try to get operator version from current cluster
+        current_cluster = Config::ClusterConfig.current_cluster
+        if current_cluster
+          cluster_config = Config::ClusterConfig.get_cluster(current_cluster)
+          begin
+            k8s = Kubernetes::Client.new(
+              kubeconfig: cluster_config[:kubeconfig],
+              context: cluster_config[:context]
+            )
+
+            if k8s.operator_installed?
+              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}")
+          end
+        else
+          puts 'No cluster selected'
+          puts
+          puts 'Select a cluster to check operator version:'
+          puts '  aictl use <cluster>'
+        end
+      end
+
+      desc 'cluster SUBCOMMAND ...ARGS', 'Manage language clusters'
+      subcommand 'cluster', Commands::Cluster
+
+      desc 'use CLUSTER', 'Switch to a different cluster context'
+      def use(cluster_name)
+        Commands::Use.new.switch(cluster_name)
+      end
+
+      desc 'agent SUBCOMMAND ...ARGS', 'Manage autonomous agents'
+      subcommand 'agent', Commands::Agent
+
+      desc 'persona SUBCOMMAND ...ARGS', 'Manage agent personas'
+      subcommand 'persona', Commands::Persona
+
+      desc 'tool SUBCOMMAND ...ARGS', 'Manage MCP tools'
+      subcommand 'tool', Commands::Tool
+
+      desc 'model SUBCOMMAND ...ARGS', 'Manage language models'
+      subcommand 'model', Commands::Model
+
+      desc 'system SUBCOMMAND ...ARGS', 'System commands for schema and metadata'
+      subcommand 'system', Commands::System
+
+      desc 'quickstart', 'Interactive setup wizard for first-time users'
+      def quickstart
+        Commands::Quickstart.new.invoke(:start)
+      end
+
+      desc 'install', 'Install the language-operator using Helm'
+      long_desc Commands::Install.long_desc_for(:install)
+      option :values, type: :string, desc: 'Path to custom Helm values file'
+      option :namespace, type: :string, default: Commands::Install::DEFAULT_NAMESPACE, desc: 'Kubernetes namespace'
+      option :version, type: :string, desc: 'Specific chart version to install'
+      option :dry_run, type: :boolean, default: false, desc: 'Preview installation without applying'
+      option :wait, type: :boolean, default: true, desc: 'Wait for deployment to complete'
+      option :create_namespace, type: :boolean, default: true, desc: 'Create namespace if it does not exist'
+      def install
+        Commands::Install.new([], options).install
+      end
+
+      desc 'upgrade', 'Upgrade the language-operator using Helm'
+      long_desc Commands::Install.long_desc_for(:upgrade)
+      option :values, type: :string, desc: 'Path to custom Helm values file'
+      option :namespace, type: :string, default: Commands::Install::DEFAULT_NAMESPACE, desc: 'Kubernetes namespace'
+      option :version, type: :string, desc: 'Specific chart version to upgrade to'
+      option :dry_run, type: :boolean, default: false, desc: 'Preview upgrade without applying'
+      option :wait, type: :boolean, default: true, desc: 'Wait for deployment to complete'
+      def upgrade
+        Commands::Install.new([], options).upgrade
+      end
+
+      desc 'uninstall', 'Uninstall the language-operator using Helm'
+      long_desc Commands::Install.long_desc_for(:uninstall)
+      option :namespace, type: :string, default: Commands::Install::DEFAULT_NAMESPACE, desc: 'Kubernetes namespace'
+      option :force, type: :boolean, default: false, desc: 'Skip confirmation prompt'
+      def uninstall
+        Commands::Install.new([], options).uninstall
+      end
+
+      desc 'completion SHELL', 'Install shell completion for aictl (bash, zsh, fish)'
+      long_desc <<-DESC
+        Install shell completion for aictl. Supports bash, zsh, and fish.
+
+        Examples:
+          aictl completion bash
+          aictl completion zsh
+          aictl completion fish
+
+        Manual installation:
+          bash: Add to ~/.bashrc:
+            source <(aictl completion bash --stdout)
+
+          zsh: Add to ~/.zshrc:
+            source <(aictl completion zsh --stdout)
+
+          fish: Run once:
+            aictl completion fish | source
+      DESC
+      option :stdout, type: :boolean, desc: 'Print completion script to stdout instead of installing'
+      def completion(shell)
+        case shell.downcase
+        when 'bash'
+          install_bash_completion
+        when 'zsh'
+          install_zsh_completion
+        when 'fish'
+          install_fish_completion
+        else
+          Formatters::ProgressFormatter.error("Unsupported shell: #{shell}")
+          puts
+          puts 'Supported shells: bash, zsh, fish'
+          exit 1
+        end
+      end
+
+      private
+
+      def install_bash_completion
+        completion_file = File.expand_path('../../completions/aictl.bash', __dir__)
+
+        if options[:stdout]
+          puts File.read(completion_file)
+          return
+        end
+
+        target = File.expand_path('~/.bash_completion.d/aictl')
+        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
+        puts 'Then reload your shell:'
+        puts '  source ~/.bashrc'
+      end
+
+      def install_zsh_completion
+        completion_file = File.expand_path('../../completions/_aictl', __dir__)
+
+        if options[:stdout]
+          puts File.read(completion_file)
+          return
+        end
+
+        # Check if user has a custom fpath directory
+        fpath_dir = File.expand_path('~/.zsh/completions')
+        FileUtils.mkdir_p(fpath_dir)
+
+        target = File.join(fpath_dir, '_aictl')
+        FileUtils.cp(completion_file, target)
+
+        Formatters::ProgressFormatter.success('Zsh completion installed')
+        puts
+        puts 'Add to your ~/.zshrc (before compinit):'
+        puts '  fpath=(~/.zsh/completions $fpath)'
+        puts '  autoload -Uz compinit && compinit'
+        puts
+        puts 'Then reload your shell:'
+        puts '  source ~/.zshrc'
+      end
+
+      def install_fish_completion
+        completion_file = File.expand_path('../../completions/aictl.fish', __dir__)
+
+        if options[:stdout]
+          puts File.read(completion_file)
+          return
+        end
+
+        target = File.expand_path('~/.config/fish/completions/aictl.fish')
+        FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.cp(completion_file, target)
+
+        Formatters::ProgressFormatter.success('Fish completion installed')
+        puts
+        puts 'Reload completions:'
+        puts '  fish_update_completions'
+        puts
+        puts 'Or restart your fish shell'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+apiVersion: langop.io/v1alpha1
+kind: LanguageTool
+metadata:
+  name: <%= name %>
+  namespace: <%= namespace %>
+spec:
+  type: <%= type || 'mcp' %>
+  image: <%= image || "changeme/#{name}-tool:latest" %>
+  imagePullPolicy: Always
+  deploymentMode: <%= deployment_mode || 'sidecar' %>
+  port: <%= port || 8080 %>
+
+  resources:
+    requests:
+      cpu: 50m
+      memory: 64Mi
+    limits:
+      cpu: 200m
+      memory: 256Mi
+
+<% if egress && !egress.empty? -%>
+  egress:
+<% egress.each do |rule| -%>
+    - description: <%= rule['description'] %>
+<% if rule['cidr'] -%>
+      cidr: <%= rule['cidr'] %>
+<% end -%>
+<% if rule['dns'] -%>
+      dns:
+<% rule['dns'].each do |dns| -%>
+        - "<%= dns %>"
+<% end -%>
+<% end -%>
+<% if rule['ports'] -%>
+      ports:
+<% rule['ports'].each do |port_rule| -%>
+        - port: <%= port_rule['port'] %>
+          protocol: <%= port_rule['protocol'] %>
+<% end -%>
+<% end -%>
+<% end -%>
+<% else -%>
+  egress: []
+<% end -%>
+
+<% if rbac -%>
+  rbac:
+<% if rbac['clusterRole'] -%>
+    clusterRole:
+      rules:
+<% rbac['clusterRole']['rules'].each do |rule| -%>
+        - apiGroups:
+<% rule['apiGroups'].each do |group| -%>
+            - <%= group %>
+<% end -%>
+          resources:
+<% rule['resources'].each do |resource| -%>
+            - <%= resource %>
+<% end -%>
+          verbs:
+<% rule['verbs'].each do |verb| -%>
+            - <%= verb %>
+<% end -%>
+<% end -%>
+<% end -%>
+<% end -%>

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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'pastel'
+require_relative '../helpers/schedule_builder'
+
+module LanguageOperator
+  module CLI
+    module Wizards
+      # Interactive wizard for creating agents
+      class AgentWizard
+        attr_reader :prompt, :pastel
+
+        def initialize
+          @prompt = TTY::Prompt.new
+          @pastel = Pastel.new
+        end
+
+        # Run the wizard and return the generated description
+        def run
+          show_welcome
+
+          # Step 1: Get task description
+          task = ask_task_description
+
+          # Step 2: Determine schedule
+          schedule_info = ask_schedule
+
+          # Step 3: Tool detection and configuration
+          tools_config = configure_tools(task)
+
+          # Step 4: Preview and confirm
+          description = build_description(task, schedule_info, tools_config)
+
+          show_preview(description, schedule_info, tools_config)
+
+          return nil unless confirm_creation?
+
+          description
+        end
+
+        private
+
+        def show_welcome
+          puts
+          puts pastel.cyan('╭────────────────────────────────────────╮')
+          puts pastel.cyan('│  Let\'s create your agent! 🤖           │')
+          puts pastel.cyan('╰────────────────────────────────────────╯')
+          puts
+        end
+
+        def ask_task_description
+          prompt.ask('What should your agent do?') do |q|
+            q.required true
+            q.validate(/\w+/)
+            q.messages[:valid?] = 'Please describe a task (cannot be empty)'
+          end
+        end
+
+        def ask_schedule
+          puts
+          schedule_type = prompt.select('How often should it run?') do |menu|
+            menu.choice 'Every day at a specific time', :daily
+            menu.choice 'Every few minutes/hours', :interval
+            menu.choice 'Continuously (whenever something changes)', :continuous
+            menu.choice 'Only when I trigger it manually', :manual
+          end
+
+          case schedule_type
+          when :daily
+            ask_daily_schedule
+          when :interval
+            ask_interval_schedule
+          when :continuous
+            { type: :continuous, description: 'continuously' }
+          when :manual
+            { type: :manual, description: 'on manual trigger' }
+          end
+        end
+
+        def ask_daily_schedule
+          puts
+          time_input = prompt.ask('What time each day? (e.g., 4pm, 9:30am, 16:00):') do |q|
+            q.required true
+            q.validate(lambda do |input|
+              Helpers::ScheduleBuilder.parse_time(input)
+              true
+            rescue ArgumentError
+              false
+            end)
+            q.messages[:valid?] = 'Invalid time format. Try: 4pm, 9:30am, or 16:00'
+          end
+
+          time_24h = Helpers::ScheduleBuilder.parse_time(time_input)
+          cron = Helpers::ScheduleBuilder.daily_cron(time_24h)
+
+          {
+            type: :daily,
+            time: time_24h,
+            cron: cron,
+            description: "daily at #{time_input}"
+          }
+        end
+
+        def ask_interval_schedule
+          puts
+          interval = prompt.ask('How often?', convert: :int) do |q|
+            q.required true
+            q.validate(->(v) { v.to_i.positive? })
+            q.messages[:valid?] = 'Please enter a positive number'
+          end
+
+          unit = prompt.select('Minutes, hours, or days?', %w[minutes hours days])
+
+          cron = Helpers::ScheduleBuilder.interval_cron(interval, unit)
+
+          {
+            type: :interval,
+            interval: interval,
+            unit: unit,
+            cron: cron,
+            description: "every #{interval} #{unit}"
+          }
+        end
+
+        def configure_tools(task_description)
+          detected = detect_tools(task_description)
+          config = {}
+
+          return config if detected.empty?
+
+          puts
+          puts "I detected these tools: #{pastel.yellow(detected.join(', '))}"
+          puts
+
+          detected.each do |tool|
+            case tool
+            when 'email'
+              config[:email] = ask_email_config
+            when 'google-sheets', 'spreadsheet'
+              config[:spreadsheet] = ask_spreadsheet_config
+            when 'slack'
+              config[:slack] = ask_slack_config
+            end
+          end
+
+          config[:tools] = detected
+          config
+        end
+
+        def detect_tools(description)
+          tools = []
+          text = description.downcase
+
+          tools << 'email' if text.match?(/email|mail|send.*message/i)
+          tools << 'google-sheets' if text.match?(/spreadsheet|sheet|excel|csv/i)
+          tools << 'slack' if text.match?(/slack/i)
+          tools << 'github' if text.match?(/github|git|repo/i)
+
+          tools
+        end
+
+        def ask_email_config
+          email = prompt.ask('Your email for notifications:') do |q|
+            q.required true
+            q.validate(/\A[\w+\-.]+@[a-z\d-]+(\.[a-z\d-]+)*\.[a-z]+\z/i)
+            q.messages[:valid?] = 'Please enter a valid email address'
+          end
+          { address: email }
+        end
+
+        def ask_spreadsheet_config
+          url = prompt.ask('Spreadsheet URL:') do |q|
+            q.required true
+            q.validate(%r{^https?://}i)
+            q.messages[:valid?] = 'Please enter a valid URL'
+          end
+          { url: url }
+        end
+
+        def ask_slack_config
+          channel = prompt.ask('Slack channel (e.g., #general):') do |q|
+            q.required true
+          end
+          { channel: channel }
+        end
+
+        def build_description(task, schedule_info, tools_config)
+          parts = [task]
+
+          # Add schedule information
+          case schedule_info[:type]
+          when :daily
+            parts << schedule_info[:description]
+          when :interval
+            parts << schedule_info[:description]
+          when :continuous
+            # "continuously" might already be implied in task
+            parts << 'continuously' unless task.downcase.include?('continuous')
+          when :manual
+            # Manual trigger doesn't need to be in description
+          end
+
+          # Add tool-specific details
+          parts << "and email me at #{tools_config[:email][:address]}" if tools_config[:email]
+
+          if tools_config[:spreadsheet] && !task.include?('http')
+            # Replace generic "spreadsheet" with specific URL if not already present
+            parts << "using spreadsheet at #{tools_config[:spreadsheet][:url]}"
+          end
+
+          parts << "and send results to #{tools_config[:slack][:channel]}" if tools_config[:slack]
+
+          parts.join(' ')
+        end
+
+        def show_preview(description, schedule_info, tools_config)
+          puts
+          puts pastel.cyan('╭─ Preview ──────────────────────────────╮')
+          puts '│'
+          puts "│  #{pastel.bold('Task:')} #{description}"
+
+          if schedule_info[:type] == :manual
+            puts "│  #{pastel.bold('Mode:')} Manual trigger"
+          else
+            schedule_text = schedule_info[:description] || 'on demand'
+            puts "│  #{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?
+
+          puts '│'
+          puts pastel.cyan('╰────────────────────────────────────────╯')
+          puts
+        end
+
+        def confirm_creation?
+          puts
+          prompt.yes?('Create this agent?')
+        end
+      end
+    end
+  end
+end