walheim 0.1.2 → 0.2.1

data/lib/walheim/cli/base_command.rb

@@ -0,0 +1,171 @@
+# 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
+      validate_namespace_options!(operation, kind, name, options) if handler.is_a?(Walheim::NamespacedResource)
+
+      # 6. Dispatch to handler
+      dispatch_to_handler(handler, operation, name, options, handler_info)
+    end
+
+    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 = %i[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
+      return if options[:namespace]
+
+      warn "Error: -n {namespace} is required"
+      warn "Usage: whctl #{operation} #{kind} {name} -n {namespace}"
+      exit 1
+    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
+      elsif handler.is_a?(Walheim::NamespacedResource)
+        # Apply from existing manifest in data dir
+        handler.apply(namespace: options[:namespace], name: name)
+      else
+        handler.apply(name: name)
+      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
+      headers = if all_namespaces
+                  %w[NAMESPACE NAME] + summary_fields.map(&:to_s).map(&:upcase)
+      else
+                  [ "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.safe_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,53 @@
+# 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]
+        next unless handler_class.respond_to?(:operation_info)
+
+        op_metadata = handler_class.operation_info[operation]
+        all_options.merge!(op_metadata[:options]) if op_metadata && op_metadata[:options]
+      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 do |v|
+            options[v.name]
+          rescue StandardError
+            nil
+          end
+        )
+      end
+    end
+  end
+end

data/lib/walheim/cli.rb

@@ -0,0 +1,63 @@
+# 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/cluster_resource.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'resource'
+require_relative "resource"
 
 module Walheim
   # ClusterResource represents resources that are cluster-scoped (not namespaced)
@@ -69,9 +69,9 @@ module Walheim
     # Apply operation - create or update
     def apply(name:, manifest_source: nil)
       manifest_data = if manifest_source
-        File.read(manifest_source)
+                        File.read(manifest_source)
       else
-        read_manifest_from_db(name)
+                        read_manifest_from_db(name)
       end
 
       if resource_exists?(name)
@@ -91,7 +91,7 @@ module Walheim
 
       manifest_path = File.join(resource_dir(name), manifest_filename)
       manifest_content = File.read(manifest_path)
-      manifest_data = YAML.load(manifest_content)
+      manifest_data = YAML.safe_load(manifest_content)
 
       # Compute summary fields
       summary = {}
@@ -123,7 +123,7 @@ module Walheim
     def find_resource_names
       base_dir = File.join(@data_dir, self.class.kind_info[:plural])
       Dir.entries(base_dir)
-         .select { |entry| File.directory?(File.join(base_dir, entry)) && !entry.start_with?('.') }
+         .select { |entry| File.directory?(File.join(base_dir, entry)) && !entry.start_with?(".") }
          .select { |entry| File.exist?(File.join(base_dir, entry, manifest_filename)) }
          .sort
     end