walheim 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d19e8685c0c52cb39ba23885c62d508846a85bb92b378634ccf577f3f8b3cd9
-  data.tar.gz: da82158c9db6c6c4a34633d10ca7c0c532ad3ead820dd244339d64ebd77182be
+  metadata.gz: c859436cfcc9582a4a875cf547855472d592b37e391f58abadd0003943272d1d
+  data.tar.gz: 15b5ad58f1c94475882e31c41c203f6a8446a63629ed7543957fc3244282be2b
 SHA512:
-  metadata.gz: b995e6d2017d058690016d58881af050cd1f0c629c6a38ff741f29d11df27ffc86050f8ea17e0a1c83964f29a6c87a7a003e94b6f2fac9ce593d6c08b53d68bc
-  data.tar.gz: cce38837eb9ba755d59463334c03b8e383f6cf9484b0062625695af198ac637bb648e1c3e93d28f42b30966edfa04b8b04f028d793d0befc60c9f11a4363fbc1
+  metadata.gz: b4c2b0a0ff5d4e6ca42d2ac2159c85689fc7faca2f633061d11b8d3cb8a2cf3bf2d4e9d07c35ca6d2abfb9768fbdcaacd49a0ccb673ba0b0cab55da3ec80c5ba
+  data.tar.gz: 2c1c9369e7372cf6c21d1771870e805e43f10a8a082dc886d4a18e6f7ad70bd272e50bb3463c6cafeb8a37acf5a351b0d7efe5ba12b070c6ae45092d92e4d375

data/README.md

@@ -1,5 +1,7 @@
 # Walheim
 
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/walheimlab/walheim-rb)
+
 A kubectl-style CLI for managing Docker-based homelab infrastructure across multiple machines.
 
 ## Overview

data/lib/walheim/cli/base_command.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'helpers'
+require_relative "helpers"
 
 module Walheim
   module BaseCommand
@@ -9,35 +9,39 @@ module Walheim
       handler_info = Walheim::HandlerRegistry.get(kind)
       unless handler_info
         warn "Error: unknown kind '#{kind}'"
-        warn ''
-        warn 'Available kinds:'
+        warn ""
+        warn "Available kinds:"
         Walheim::HandlerRegistry.all_visible.each { |h| warn "  #{h[:name]}" }
         exit 1
       end
 
       # 2. Check operation support
+      handler_class = handler_info[:handler]
       unless Walheim::HandlerRegistry.supports_operation?(kind, operation)
         warn "Error: #{operation} not supported for #{kind}"
         exit 1
       end
 
-      # 3. Resolve data directory from context
+      # 3. Get operation metadata
+      op_metadata = handler_class.operation_info[operation]
+      unless op_metadata
+        warn "Error: operation metadata missing for #{operation}"
+        exit 1
+      end
+
+      # 4. 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. Initialize handler
+      handler = handler_class.new(data_dir: data_dir)
 
-      # 5. Validate namespace requirements
-      if handler.is_a?(Walheim::NamespacedResource)
-        validate_namespace_options!(operation, kind, name, options)
-      end
+      # 6. Validate namespace requirements
+      validate_namespace_requirements!(operation, kind, name, options, op_metadata) if handler.is_a?(Walheim::NamespacedResource)
 
-      # 6. Dispatch to handler
-      dispatch_to_handler(handler, operation, name, options, handler_info)
+      # 7. Dispatch to handler using metadata
+      dispatch_operation(handler, operation, name, options, handler_info, op_metadata)
     end
 
-    private
-
     def self.resolve_data_dir(options, parent_options)
       # Merge options
       all_options = parent_options.merge(options)
@@ -51,125 +55,120 @@ module Walheim
         if context_name
           config.data_dir(context_name)
         elsif all_options[:data_dir]
-          warn 'Warning: --data-dir is deprecated. Use contexts.'
+          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>'
+          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.'
+          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>'
+          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)
+    def self.validate_namespace_requirements!(operation, kind, _name, options, op_metadata)
+      dispatch_meta = op_metadata[:dispatch] || {}
+      namespace_handling = dispatch_meta[:namespace_handling]
 
-      # get can use --all
-      if operation == :get
+      case namespace_handling
+      when :optional_with_all
+        # Operations like get can use --all or -n
         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"
+
+        warn "Error: either -n {namespace} or --all/-A flag is required"
+        warn "Usage: whctl #{operation} #{kind} -n {namespace}"
+        warn "Usage: whctl #{operation} #{kind} --all"
         exit 1
-      end
+      when :required
+        # Operations require namespace
+        return if options[:namespace]
 
-      # Other operations require namespace
-      unless options[:namespace]
-        warn 'Error: -n {namespace} is required'
+        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)
+      when nil
+        # No namespace validation needed
+        nil
       else
-        warn "Error: operation #{operation} not implemented"
+        warn "Error: unknown namespace_handling: #{namespace_handling}"
         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)
+    def self.dispatch_operation(handler, operation, name, options, handler_info, op_metadata)
+      dispatch_meta = op_metadata[:dispatch] || {}
+      method_name = dispatch_meta[:method] || operation
+
+      # Build method parameters
+      params = build_method_params(name, options, dispatch_meta)
+
+      # Call handler method
+      result = handler.send(method_name, **params)
+
+      # Handle output formatting
+      handle_output(result, handler, handler_info, options, dispatch_meta)
+    end
+
+    def self.build_method_params(name, options, dispatch_meta)
+      params = {}
+
+      # Add positional params (like :name)
+      positional_params = dispatch_meta[:params] || []
+      positional_params.each do |param_name|
+        case param_name
+        when :name
+          params[:name] = name
         else
-          handler.get(namespace: options[:namespace], name: name)
+          params[param_name] = options[param_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])
+      # Add named params from options
+      named_params = dispatch_meta[:named_params] || {}
+      named_params.each do |param_name, option_key|
+        option_value = options[option_key]
 
-        if handler.is_a?(Walheim::NamespacedResource)
-          namespace = manifest_data['metadata']['namespace']
-          name = manifest_data['metadata']['name']
+        # Handle file readers
+        if dispatch_meta[:file_reader] == param_name && option_value
+          option_value = Walheim::Helpers.read_yaml_input(option_value)
+        end
 
-          unless namespace && name
-            warn 'Error: Manifest must contain metadata.namespace and metadata.name'
-            exit 1
-          end
+        # Always include declared parameters (handlers expect them as keyword args)
+        params[param_name] = option_value
+      end
 
-          handler.apply(namespace: namespace, name: name, manifest_source: options[:file])
+      params
+    end
+
+    def self.handle_output(result, handler, handler_info, options, dispatch_meta)
+      output_type = dispatch_meta[:output]
+
+      case output_type
+      when :table
+        # Table output for get operations
+        if handler.is_a?(Walheim::ClusterResource)
+          Walheim::Helpers.print_cluster_resources_table(result, handler_info[:name])
         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])
+          Walheim::Helpers.print_resources_table(result, options[:all], handler_info[:name])
         end
+      when nil
+        # No output handling needed (handler prints directly)
+        nil
       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
+        warn "Error: unknown output type: #{output_type}"
+        exit 1
       end
     end
   end

data/lib/walheim/cli/helpers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'terminal-table'
-require 'yaml'
+require "terminal-table"
+require "yaml"
 
 module Walheim
   module Helpers
@@ -22,31 +22,31 @@ module Walheim
       summary_fields = result.first[:summary].keys
 
       # Build header row
-      if all_namespaces
-        headers = ['NAMESPACE', 'NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+      headers = if all_namespaces
+                  %w[NAMESPACE NAME] + summary_fields.map(&:to_s).map(&:upcase)
       else
-        headers = ['NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+                  [ "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]]
+                [ resource[:namespace], resource[:name] ]
         else
-          [resource[:name]]
+                [ resource[:name] ]
         end
 
         # Add summary field values
-        summary_values = summary_fields.map { |field| resource[:summary][field] || 'N/A' }
+        summary_values = summary_fields.map { |field| resource[:summary][field] || "N/A" }
         row + summary_values
       end
 
-      all_rows = [headers] + rows
+      all_rows = [ headers ] + rows
 
       table = Terminal::Table.new do |t|
         t.rows = all_rows
         t.style = {
-          border_x: '', border_y: '', border_i: '',
+          border_x: "", border_y: "", border_i: "",
           padding_left: 0, padding_right: 3,
           border_top: false, border_bottom: false,
           all_separators: false
@@ -73,23 +73,23 @@ module Walheim
       summary_fields = result.first[:summary].keys
 
       # Build header row (no NAMESPACE column for cluster resources)
-      headers = ['NAME'] + summary_fields.map(&:to_s).map(&:upcase)
+      headers = [ "NAME" ] + summary_fields.map(&:to_s).map(&:upcase)
 
       # Build data rows
       rows = result.map do |resource|
-        row = [resource[:name]]
+        row = [ resource[:name] ]
 
         # Add summary field values
-        summary_values = summary_fields.map { |field| resource[:summary][field] || 'N/A' }
+        summary_values = summary_fields.map { |field| resource[:summary][field] || "N/A" }
         row + summary_values
       end
 
-      all_rows = [headers] + rows
+      all_rows = [ headers ] + rows
 
       table = Terminal::Table.new do |t|
         t.rows = all_rows
         t.style = {
-          border_x: '', border_y: '', border_i: '',
+          border_x: "", border_y: "", border_i: "",
           padding_left: 0, padding_right: 3,
           border_top: false, border_bottom: false,
           all_separators: false
@@ -101,9 +101,9 @@ module Walheim
 
     # Read YAML from file or stdin
     def self.read_yaml_input(file_path)
-      if file_path == '-'
+      if file_path == "-"
         # Read from stdin
-        YAML.load(STDIN.read)
+        YAML.safe_load($stdin.read)
       else
         # Read from file
         YAML.load_file(file_path)

data/lib/walheim/cli/legacy_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'optparse'
-require 'terminal-table'
+require "optparse"
+require "terminal-table"
 
 module Walheim
   module LegacyContext
@@ -9,12 +9,12 @@ module Walheim
       options = {}
 
       # Remove 'context' from argv since it's already been identified
-      argv.shift if argv[0] == 'context'
+      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 }
+        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)
@@ -30,17 +30,17 @@ module Walheim
       context_name = argv[1]
 
       case subcommand
-      when 'new'
+      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}'
+          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}'
+          warn "Error: --data-dir flag is required"
+          warn "Usage: whctl context new {name} --data-dir {path}"
           exit 1
         end
 
@@ -48,19 +48,19 @@ module Walheim
         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'
+          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')
+        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...'
+          warn ""
+          warn "This directory should contain your homelab configuration."
+          warn "Creating namespaces directory..."
           Dir.mkdir(namespaces_path)
         end
 
@@ -81,34 +81,34 @@ module Walheim
           exit 1
         end
 
-      when 'list'
+      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>'
+          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.'
+          puts "No contexts configured."
           exit 0
         end
 
         rows = contexts.map do |ctx|
-          active_marker = ctx['active'] ? '*' : ''
-          [active_marker, ctx['name'], ctx['dataDir']]
+          active_marker = ctx["active"] ? "*" : ""
+          [ active_marker, ctx["name"], ctx["dataDir"] ]
         end
 
         table = Terminal::Table.new do |t|
-          t.headings = ['CURRENT', 'NAME', 'DATA DIRECTORY']
+          t.headings = [ "CURRENT", "NAME", "DATA DIRECTORY" ]
           t.rows = rows
           t.style = {
-            border_x: '', border_y: '', border_i: '',
+            border_x: "", border_y: "", border_i: "",
             padding_left: 0, padding_right: 3,
             border_top: false, border_bottom: false,
             all_separators: false
@@ -117,11 +117,11 @@ module Walheim
 
         puts table
 
-      when 'use'
+      when "use"
         # whctl context use {name}
         unless context_name
-          warn 'Error: context name is required'
-          warn 'Usage: whctl context use {name}'
+          warn "Error: context name is required"
+          warn "Usage: whctl context use {name}"
           exit 1
         end
 
@@ -136,15 +136,15 @@ module Walheim
           exit 1
         end
 
-      when 'current'
+      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>'
+          warn "No Walheim configuration found."
+          warn ""
+          warn "Create your first context:"
+          warn "  whctl context new <name> --data-dir <path>"
           exit 1
         end
 
@@ -152,22 +152,22 @@ module Walheim
           puts "Current context: #{config.current_context}"
           puts "Data directory: #{config.data_dir}"
         else
-          puts 'No active context selected.'
-          puts ''
-          puts 'Available contexts:'
+          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>'
+          puts ""
+          puts "Select a context:"
+          puts "  whctl context use <context-name>"
         end
 
-      when 'delete'
+      when "delete"
         # whctl context delete {name}
         unless context_name
-          warn 'Error: context name is required'
-          warn 'Usage: whctl context delete {name}'
+          warn "Error: context name is required"
+          warn "Usage: whctl context delete {name}"
           exit 1
         end
 
@@ -180,10 +180,10 @@ module Walheim
 
           # 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>'
+            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}"
@@ -192,13 +192,13 @@ module Walheim
 
       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}'
+        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

data/lib/walheim/cli/resource_command.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'base_command'
+require_relative "base_command"
 
 module Walheim
   module ResourceCommand
@@ -10,7 +10,7 @@ module Walheim
       return if handlers.empty?
 
       # Build command description
-      descriptions = handlers.map { |h| h[:name] }.join(', ')
+      descriptions = handlers.map { |h| h[:name] }.join(", ")
       desc_text = "#{operation.to_s.capitalize} resources (#{descriptions})"
 
       # Define Thor command
@@ -21,12 +21,10 @@ module Walheim
       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
+        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
@@ -43,7 +41,11 @@ module Walheim
           kind: kind,
           name: name,
           options: options,
-          parent_options: self.class.class_options.transform_keys(&:to_sym).transform_values { |v| options[v.name] rescue nil }
+          parent_options: self.class.class_options.transform_keys(&:to_sym).transform_values do |v|
+            options[v.name]
+          rescue StandardError
+            nil
+          end
         )
       end
     end