walheim 0.1.2 → 0.2.0

data/lib/walheim/cli/base_command.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative 'helpers'
+
+module Walheim
+  module BaseCommand
+    def self.execute(operation:, kind:, name:, options:, parent_options:)
+      # 1. Resolve handler
+      handler_info = Walheim::HandlerRegistry.get(kind)
+      unless handler_info
+        warn "Error: unknown kind '#{kind}'"
+        warn ''
+        warn 'Available kinds:'
+        Walheim::HandlerRegistry.all_visible.each { |h| warn "  #{h[:name]}" }
+        exit 1
+      end
+
+      # 2. Check operation support
+      unless Walheim::HandlerRegistry.supports_operation?(kind, operation)
+        warn "Error: #{operation} not supported for #{kind}"
+        exit 1
+      end
+
+      # 3. Resolve data directory from context
+      data_dir = resolve_data_dir(options, parent_options)
+
+      # 4. Initialize handler
+      handler = handler_info[:handler].new(data_dir: data_dir)
+
+      # 5. Validate namespace requirements
+      if handler.is_a?(Walheim::NamespacedResource)
+        validate_namespace_options!(operation, kind, name, options)
+      end
+
+      # 6. Dispatch to handler
+      dispatch_to_handler(handler, operation, name, options, handler_info)
+    end
+
+    private
+
+    def self.resolve_data_dir(options, parent_options)
+      # Merge options
+      all_options = parent_options.merge(options)
+
+      # Try to load config
+      begin
+        config = Walheim::Config.new(config_path: all_options[:whconfig])
+
+        context_name = all_options[:context] || config.current_context
+
+        if context_name
+          config.data_dir(context_name)
+        elsif all_options[:data_dir]
+          warn 'Warning: --data-dir is deprecated. Use contexts.'
+          all_options[:data_dir]
+        else
+          warn 'Error: No Walheim configuration found.'
+          warn ''
+          warn 'Create your first context:'
+          warn '  whctl context new <name> --data-dir <path>'
+          exit 1
+        end
+      rescue Walheim::Config::ConfigError, Walheim::Config::ValidationError
+        if all_options[:data_dir]
+          warn 'Warning: --data-dir is deprecated.'
+          all_options[:data_dir]
+        else
+          warn 'Error: No Walheim configuration found.'
+          warn ''
+          warn 'Create your first context:'
+          warn '  whctl context new <name> --data-dir <path>'
+          exit 1
+        end
+      end
+    end
+
+    def self.validate_namespace_options!(operation, kind, name, options)
+      # Operations that require namespace or --all
+      requires_namespace = [:get, :apply, :delete, :start, :pause, :stop, :logs, :import]
+      return unless requires_namespace.include?(operation)
+
+      # get can use --all
+      if operation == :get
+        return if options[:all] || options[:namespace]
+        warn 'Error: either -n {namespace} or --all/-A flag is required'
+        warn "Usage: whctl get #{kind} -n {namespace}"
+        warn "Usage: whctl get #{kind} --all"
+        exit 1
+      end
+
+      # Other operations require namespace
+      unless options[:namespace]
+        warn 'Error: -n {namespace} is required'
+        warn "Usage: whctl #{operation} #{kind} {name} -n {namespace}"
+        exit 1
+      end
+    end
+
+    def self.dispatch_to_handler(handler, operation, name, options, handler_info)
+      case operation
+      when :get
+        dispatch_get(handler, name, options, handler_info)
+      when :apply
+        dispatch_apply(handler, name, options, handler_info)
+      when :delete
+        handler.delete(namespace: options[:namespace], name: name)
+      when :create
+        # Special case: create namespace
+        handler.create(name: name, username: options[:username], hostname: options[:hostname])
+      when :import
+        # Special case: import app
+        compose_manifest = Walheim::Helpers.read_yaml_input(options[:file])
+        handler.import(namespace: options[:namespace], name: name, compose_manifest: compose_manifest)
+      when :start, :pause, :stop
+        handler.send(operation, namespace: options[:namespace], name: name)
+      when :logs
+        log_opts = {}
+        log_opts[:follow] = options[:follow] if options[:follow]
+        log_opts[:tail] = options[:tail] if options[:tail]
+        log_opts[:timestamps] = options[:timestamps] if options[:timestamps]
+        handler.logs(namespace: options[:namespace], name: name, **log_opts)
+      else
+        warn "Error: operation #{operation} not implemented"
+        exit 1
+      end
+    end
+
+    def self.dispatch_get(handler, name, options, handler_info)
+      if handler.is_a?(Walheim::ClusterResource)
+        result = handler.get(name: name)
+        Walheim::Helpers.print_cluster_resources_table(result, handler_info[:name])
+      else
+        result = if options[:all]
+          handler.get(namespace: nil, name: nil)
+        else
+          handler.get(namespace: options[:namespace], name: name)
+        end
+        Walheim::Helpers.print_resources_table(result, options[:all], handler_info[:name])
+      end
+    end
+
+    def self.dispatch_apply(handler, name, options, handler_info)
+      # Extract from manifest if -f provided
+      if options[:file]
+        manifest_data = Walheim::Helpers.read_yaml_input(options[:file])
+
+        if handler.is_a?(Walheim::NamespacedResource)
+          namespace = manifest_data['metadata']['namespace']
+          name = manifest_data['metadata']['name']
+
+          unless namespace && name
+            warn 'Error: Manifest must contain metadata.namespace and metadata.name'
+            exit 1
+          end
+
+          handler.apply(namespace: namespace, name: name, manifest_source: options[:file])
+        else
+          # Cluster resource
+          name = manifest_data['metadata']['name']
+          unless name
+            warn 'Error: Manifest must contain metadata.name'
+            exit 1
+          end
+          handler.apply(name: name, manifest_source: options[:file])
+        end
+      else
+        # Apply from existing manifest in data dir
+        if handler.is_a?(Walheim::NamespacedResource)
+          handler.apply(namespace: options[:namespace], name: name)
+        else
+          handler.apply(name: name)
+        end
+      end
+    end
+  end
+end

data/lib/walheim/cli/helpers.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'terminal-table'
+require 'yaml'
+
+module Walheim
+  module Helpers
+    # Print resources table for namespaced resources
+    def self.print_resources_table(result, all_namespaces, kind_name)
+      if result.is_a?(Hash)
+        # Single resource - print YAML
+        puts YAML.dump(result[:manifest])
+        return
+      end
+
+      if result.empty?
+        puts all_namespaces ? "No #{kind_name} found" : "No #{kind_name} found in namespace"
+        return
+      end
+
+      # Extract summary field names from first result
+      summary_fields = result.first[:summary].keys
+
+      # Build header row
+      if all_namespaces
+        headers = ['NAMESPACE', 'NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+      else
+        headers = ['NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+      end
+
+      # Build data rows
+      rows = result.map do |resource|
+        row = if all_namespaces
+          [resource[:namespace], resource[:name]]
+        else
+          [resource[:name]]
+        end
+
+        # Add summary field values
+        summary_values = summary_fields.map { |field| resource[:summary][field] || 'N/A' }
+        row + summary_values
+      end
+
+      all_rows = [headers] + rows
+
+      table = Terminal::Table.new do |t|
+        t.rows = all_rows
+        t.style = {
+          border_x: '', border_y: '', border_i: '',
+          padding_left: 0, padding_right: 3,
+          border_top: false, border_bottom: false,
+          all_separators: false
+        }
+      end
+
+      puts table
+    end
+
+    # Print resources table for cluster resources
+    def self.print_cluster_resources_table(result, kind_name)
+      if result.is_a?(Hash)
+        # Single resource - print YAML
+        puts YAML.dump(result[:manifest])
+        return
+      end
+
+      if result.empty?
+        puts "No #{kind_name} found"
+        return
+      end
+
+      # Extract summary field names from first result
+      summary_fields = result.first[:summary].keys
+
+      # Build header row (no NAMESPACE column for cluster resources)
+      headers = ['NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+
+      # Build data rows
+      rows = result.map do |resource|
+        row = [resource[:name]]
+
+        # Add summary field values
+        summary_values = summary_fields.map { |field| resource[:summary][field] || 'N/A' }
+        row + summary_values
+      end
+
+      all_rows = [headers] + rows
+
+      table = Terminal::Table.new do |t|
+        t.rows = all_rows
+        t.style = {
+          border_x: '', border_y: '', border_i: '',
+          padding_left: 0, padding_right: 3,
+          border_top: false, border_bottom: false,
+          all_separators: false
+        }
+      end
+
+      puts table
+    end
+
+    # Read YAML from file or stdin
+    def self.read_yaml_input(file_path)
+      if file_path == '-'
+        # Read from stdin
+        YAML.load(STDIN.read)
+      else
+        # Read from file
+        YAML.load_file(file_path)
+      end
+    end
+  end
+end

data/lib/walheim/cli/legacy_context.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'terminal-table'
+
+module Walheim
+  module LegacyContext
+    def self.execute(argv)
+      options = {}
+
+      # Remove 'context' from argv since it's already been identified
+      argv.shift if argv[0] == 'context'
+
+      # Parse global flags
+      global_parser = OptionParser.new do |opts|
+        opts.on('--whconfig PATH', 'Alternate config file path') { |v| options[:whconfig] = v }
+        opts.on('-d DIR', '--data-dir DIR', 'Data directory') { |v| options[:data_dir] = v }
+      end
+
+      # Parse global flags (use parse! to consume all flags)
+      begin
+        global_parser.parse!(argv)
+      rescue OptionParser::InvalidOption => e
+        warn "Error: #{e.message}"
+        exit 1
+      end
+
+      # Get subcommand and context name (now argv only contains non-flag arguments)
+      subcommand = argv[0]
+      context_name = argv[1]
+
+      case subcommand
+      when 'new'
+        # whctl context new {name} --data-dir {path}
+        unless context_name
+          warn 'Error: context name is required'
+          warn 'Usage: whctl context new {name} --data-dir {path}'
+          exit 1
+        end
+
+        unless options[:data_dir]
+          warn 'Error: --data-dir flag is required'
+          warn 'Usage: whctl context new {name} --data-dir {path}'
+          exit 1
+        end
+
+        # Validate data_dir exists
+        expanded_data_dir = File.expand_path(options[:data_dir])
+        unless Dir.exist?(expanded_data_dir)
+          warn "Error: data directory '#{expanded_data_dir}' does not exist"
+          warn ''
+          warn 'Please create the directory first or provide a valid path'
+          exit 1
+        end
+
+        # Check for namespaces subdirectory
+        namespaces_path = File.join(expanded_data_dir, 'namespaces')
+        unless Dir.exist?(namespaces_path)
+          warn "Warning: data directory does not contain 'namespaces' subdirectory"
+          warn "Expected path: #{namespaces_path}"
+          warn ''
+          warn 'This directory should contain your homelab configuration.'
+          warn 'Creating namespaces directory...'
+          Dir.mkdir(namespaces_path)
+        end
+
+        # Load or create config
+        config = Walheim::Config.new(config_path: options[:whconfig])
+
+        begin
+          config.add_context(context_name, expanded_data_dir, activate: true)
+          config.save_config
+          puts "Created context '#{context_name}'"
+          puts "  Data directory: #{expanded_data_dir}"
+          puts "  Status: Active (automatically activated)"
+        rescue Walheim::Config::ValidationError => e
+          warn "Error: #{e.message}"
+          exit 1
+        rescue Walheim::Config::ConfigError => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+      when 'list'
+        # whctl context list
+        config = Walheim::Config.new(config_path: options[:whconfig])
+
+        unless Walheim::Config.exists?(config_path: options[:whconfig])
+          warn 'No Walheim configuration found.'
+          warn ''
+          warn 'Create your first context:'
+          warn '  whctl context new <name> --data-dir <path>'
+          exit 1
+        end
+
+        contexts = config.list_contexts
+        if contexts.empty?
+          puts 'No contexts configured.'
+          exit 0
+        end
+
+        rows = contexts.map do |ctx|
+          active_marker = ctx['active'] ? '*' : ''
+          [active_marker, ctx['name'], ctx['dataDir']]
+        end
+
+        table = Terminal::Table.new do |t|
+          t.headings = ['CURRENT', 'NAME', 'DATA DIRECTORY']
+          t.rows = rows
+          t.style = {
+            border_x: '', border_y: '', border_i: '',
+            padding_left: 0, padding_right: 3,
+            border_top: false, border_bottom: false,
+            all_separators: false
+          }
+        end
+
+        puts table
+
+      when 'use'
+        # whctl context use {name}
+        unless context_name
+          warn 'Error: context name is required'
+          warn 'Usage: whctl context use {name}'
+          exit 1
+        end
+
+        config = Walheim::Config.new(config_path: options[:whconfig])
+
+        begin
+          config.use_context(context_name)
+          config.save_config
+          puts "Switched to context '#{context_name}'"
+        rescue Walheim::Config::ConfigError => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+      when 'current'
+        # whctl context current
+        config = Walheim::Config.new(config_path: options[:whconfig])
+
+        unless Walheim::Config.exists?(config_path: options[:whconfig])
+          warn 'No Walheim configuration found.'
+          warn ''
+          warn 'Create your first context:'
+          warn '  whctl context new <name> --data-dir <path>'
+          exit 1
+        end
+
+        if config.current_context
+          puts "Current context: #{config.current_context}"
+          puts "Data directory: #{config.data_dir}"
+        else
+          puts 'No active context selected.'
+          puts ''
+          puts 'Available contexts:'
+          config.list_contexts.each do |ctx|
+            puts "  - #{ctx['name']}"
+          end
+          puts ''
+          puts 'Select a context:'
+          puts '  whctl context use <context-name>'
+        end
+
+      when 'delete'
+        # whctl context delete {name}
+        unless context_name
+          warn 'Error: context name is required'
+          warn 'Usage: whctl context delete {name}'
+          exit 1
+        end
+
+        config = Walheim::Config.new(config_path: options[:whconfig])
+
+        begin
+          config.delete_context(context_name)
+          config.save_config
+          puts "Deleted context '#{context_name}'"
+
+          # Show warning if this was the active context
+          unless config.current_context
+            puts ''
+            puts 'Note: This was your active context.'
+            puts 'Select a new context with:'
+            puts '  whctl context use <context-name>'
+          end
+        rescue Walheim::Config::ConfigError => e
+          warn "Error: #{e.message}"
+          exit 1
+        end
+
+      else
+        warn "Error: unknown context subcommand '#{subcommand}'"
+        warn ''
+        warn 'Available context commands:'
+        warn '  whctl context new {name} --data-dir {path}'
+        warn '  whctl context list'
+        warn '  whctl context use {name}'
+        warn '  whctl context current'
+        warn '  whctl context delete {name}'
+        exit 1
+      end
+    end
+  end
+end

data/lib/walheim/cli/resource_command.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+
+module Walheim
+  module ResourceCommand
+    def self.register_operation(cli_class, operation)
+      # Get handlers supporting this operation
+      handlers = Walheim::HandlerRegistry.handlers_for_operation(operation)
+      return if handlers.empty?
+
+      # Build command description
+      descriptions = handlers.map { |h| h[:name] }.join(', ')
+      desc_text = "#{operation.to_s.capitalize} resources (#{descriptions})"
+
+      # Define Thor command
+      cli_class.desc "#{operation} KIND [NAME]", desc_text
+
+      # Add operation-specific options from handler metadata
+      # Collect all unique options across handlers for this operation
+      all_options = {}
+      handlers.each do |handler_info|
+        handler_class = handler_info[:handler]
+        if handler_class.respond_to?(:operation_info)
+          op_metadata = handler_class.operation_info[operation]
+          if op_metadata && op_metadata[:options]
+            all_options.merge!(op_metadata[:options])
+          end
+        end
+      end
+
+      # Register options with Thor
+      all_options.each do |opt_name, opt_config|
+        # Thor expects method_option calls
+        # We'll need to call this dynamically
+        cli_class.method_option opt_name, opt_config
+      end
+
+      # Define command method
+      cli_class.define_method(operation) do |kind, name = nil|
+        BaseCommand.execute(
+          operation: operation,
+          kind: kind,
+          name: name,
+          options: options,
+          parent_options: self.class.class_options.transform_keys(&:to_sym).transform_values { |v| options[v.name] rescue nil }
+        )
+      end
+    end
+  end
+end

data/lib/walheim/cli.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'cli/helpers'
+require_relative 'cli/base_command'
+require_relative 'cli/resource_command'
+
+module Walheim
+  class CLI < Thor
+    # Global flags
+    class_option :context,
+                 type: :string,
+                 desc: 'Override active context'
+
+    class_option :whconfig,
+                 type: :string,
+                 desc: 'Alternate config file path'
+
+    class_option :data_dir,
+                 type: :string,
+                 aliases: [:d],
+                 desc: 'Data directory (deprecated: use contexts)'
+
+    # Dynamically register operations
+    def self.register_operations
+      Walheim::HandlerRegistry.all_operations.each do |operation|
+        ResourceCommand.register_operation(self, operation)
+      end
+    end
+
+    # Version command
+    desc 'version', 'Show version'
+    def version
+      puts "whctl version #{Walheim::VERSION}"
+    end
+
+    # Override help to maintain kubectl-style help
+    def self.help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+
+      # Group commands by category
+      shell.say 'Usage: whctl [global flags] <command> [arguments]'
+      shell.say ''
+      shell.say 'Global flags:'
+      shell.say '  --context CONTEXT     Override active context for this command'
+      shell.say '  --whconfig PATH       Use alternate config file (default: ~/.walheim/config)'
+      shell.say '  -d, --data-dir DIR    Data directory containing namespaces (deprecated: use contexts)'
+      shell.say ''
+      shell.say 'Available commands:'
+      shell.say ''
+
+      # Print commands
+      list.each do |command|
+        next if command[0] == 'help'
+        shell.say "  #{command[0].ljust(30)} #{command[1]}"
+      end
+    end
+  end
+end

data/lib/walheim/handler_registry.rb

@@ -50,6 +50,33 @@ module Walheim
         handler_class = handler_info[:handler]
         handler_class.public_instance_methods.include?(operation.to_sym)
       end
+
+      # Get all unique operations across all handlers
+      def all_operations
+        ops = {}
+        handlers.values.uniq { |h| h[:handler] }.each do |handler_info|
+          handler_class = handler_info[:handler]
+          # Get operations from operation_info metadata
+          if handler_class.respond_to?(:operation_info)
+            handler_class.operation_info.keys.each { |op| ops[op] = true }
+          end
+        end
+        ops.keys.sort
+      end
+
+      # Get handlers supporting a specific operation
+      def handlers_for_operation(operation)
+        all_visible.select do |handler_info|
+          supports_operation?(handler_info[:name], operation)
+        end
+      end
+
+      # Check if handler is cluster or namespaced resource
+      def cluster_resource?(kind)
+        handler_info = get(kind)
+        return false unless handler_info
+        handler_info[:handler] < Walheim::ClusterResource
+      end
     end
   end
 end

data/lib/walheim/namespaced_resource.rb

@@ -7,6 +7,33 @@ module Walheim
   # Examples: Apps, Secrets, ConfigMaps
   # These resources live under namespaces/{namespace}/{kind}/{name}/
   class NamespacedResource < Resource
+    # Override operation_info to add namespace flags
+    def self.operation_info
+      ops = super
+
+      # Add namespace flags to all operations
+      namespace_options = {
+        namespace: {
+          type: :string,
+          aliases: [:n],
+          desc: 'Target namespace',
+          required: false  # Validated at runtime
+        },
+        all: {
+          type: :boolean,
+          aliases: [:A],
+          desc: 'All namespaces',
+          banner: ''  # No value needed for boolean
+        }
+      }
+
+      ops[:get][:options].merge!(namespace_options)
+      ops[:apply][:options].merge!(namespace: namespace_options[:namespace])
+      ops[:delete][:options].merge!(namespace: namespace_options[:namespace])
+
+      ops
+    end
+
     # CRUD operations for namespace-scoped resources
 
     def apply(namespace:, name:, manifest_source: nil)

data/lib/walheim/resource.rb

@@ -45,15 +45,20 @@ module Walheim
             "get #{kind_info[:plural]} -n {namespace}",
             "get #{kind_info[:plural]} --all/-A",
             "get #{kind_info[:singular]} {name} -n {namespace}"
-          ]
+          ],
+          options: {}  # Subclasses will override
         },
         apply: {
           description: 'Create or update a resource',
-          usage: ["apply #{kind_info[:singular]} {name} -n {namespace}"]
+          usage: ["apply #{kind_info[:singular]} {name} -n {namespace}"],
+          options: {
+            file: { type: :string, aliases: [:f], desc: 'Manifest file (use - for stdin)' }
+          }
         },
         delete: {
           description: 'Delete a resource',
-          usage: ["delete #{kind_info[:singular]} {name} -n {namespace}"]
+          usage: ["delete #{kind_info[:singular]} {name} -n {namespace}"],
+          options: {}  # Subclasses will override
         }
       }
     end