walheim 0.1.2 → 0.2.1

data/lib/walheim/config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'fileutils'
+require "yaml"
+require "fileutils"
 
 module Walheim
   # Configuration management for Walheim contexts
@@ -10,9 +10,9 @@ module Walheim
     class ConfigError < StandardError; end
     class ValidationError < ConfigError; end
 
-    DEFAULT_CONFIG_PATH = File.expand_path('~/.walheim/config')
-    API_VERSION = 'walheim.io/v1'
-    KIND = 'Config'
+    DEFAULT_CONFIG_PATH = File.expand_path("~/.walheim/config")
+    API_VERSION = "walheim.io/v1"
+    KIND = "Config"
 
     attr_reader :current_context, :contexts, :config_path
 
@@ -35,18 +35,18 @@ module Walheim
       data = YAML.load_file(@config_path)
       validate_schema!(data)
 
-      @current_context = data['currentContext']
-      @contexts = data['contexts'].map do |ctx|
+      @current_context = data["currentContext"]
+      @contexts = data["contexts"].map do |ctx|
         {
-          'name' => ctx['name'],
-          'dataDir' => expand_path(ctx['dataDir'])
+          "name" => ctx["name"],
+          "dataDir" => expand_path(ctx["dataDir"])
         }
       end
 
       validate_current_context!
     rescue Psych::SyntaxError => e
       raise ConfigError, "Invalid YAML in config file: #{e.message}"
-    rescue => e
+    rescue StandardError => e
       raise ConfigError, "Failed to load config: #{e.message}"
     end
 
@@ -56,13 +56,13 @@ module Walheim
     # @raise [ConfigError] if file cannot be written
     def save_config
       data = {
-        'apiVersion' => API_VERSION,
-        'kind' => KIND,
-        'currentContext' => @current_context,
-        'contexts' => @contexts.map do |ctx|
+        "apiVersion" => API_VERSION,
+        "kind" => KIND,
+        "currentContext" => @current_context,
+        "contexts" => @contexts.map do |ctx|
           {
-            'name' => ctx['name'],
-            'dataDir' => ctx['dataDir']
+            "name" => ctx["name"],
+            "dataDir" => ctx["dataDir"]
           }
         end
       }
@@ -74,7 +74,7 @@ module Walheim
       temp_file = "#{@config_path}.tmp.#{Process.pid}"
       File.write(temp_file, YAML.dump(data))
       File.rename(temp_file, @config_path)
-    rescue => e
+    rescue StandardError => e
       File.delete(temp_file) if temp_file && File.exist?(temp_file)
       raise ConfigError, "Failed to save config: #{e.message}"
     end
@@ -86,12 +86,12 @@ module Walheim
     # @raise [ConfigError] if context not found or no current context
     def data_dir(context_name = nil)
       name = context_name || @current_context
-      raise ConfigError, 'No active context selected' if name.nil?
+      raise ConfigError, "No active context selected" if name.nil?
 
       context = find_context(name)
       raise ConfigError, "Context '#{name}' not found" if context.nil?
 
-      context['dataDir']
+      context["dataDir"]
     end
 
     # Add a new context
@@ -105,8 +105,8 @@ module Walheim
       raise ValidationError, "Context '#{name}' already exists" if find_context(name)
 
       @contexts << {
-        'name' => name,
-        'dataDir' => expand_path(data_dir)
+        "name" => name,
+        "dataDir" => expand_path(data_dir)
       }
 
       @current_context = name if activate
@@ -134,6 +134,7 @@ module Walheim
     # @raise [ConfigError] if context not found
     def use_context(name)
       raise ConfigError, "Context '#{name}' not found" unless find_context(name)
+
       @current_context = name
     end
 
@@ -142,7 +143,7 @@ module Walheim
     # @return [Array<Hash>] Array of context hashes with 'name', 'dataDir', and 'active' keys
     def list_contexts
       @contexts.map do |ctx|
-        ctx.merge('active' => ctx['name'] == @current_context)
+        ctx.merge("active" => ctx["name"] == @current_context)
       end
     end
 
@@ -159,7 +160,8 @@ module Walheim
     # Resolve the config file path with precedence: param > $WHCONFIG > default
     def resolve_config_path(config_path)
       return expand_path(config_path) if config_path
-      return expand_path(ENV['WHCONFIG']) if ENV['WHCONFIG']
+      return expand_path(ENV["WHCONFIG"]) if ENV["WHCONFIG"]
+
       DEFAULT_CONFIG_PATH
     end
 
@@ -170,27 +172,27 @@ module Walheim
 
     # Find a context by name
     def find_context(name)
-      @contexts.find { |ctx| ctx['name'] == name }
+      @contexts.find { |ctx| ctx["name"] == name }
     end
 
     # Validate config schema
     def validate_schema!(data)
-      raise ValidationError, 'Config must be a Hash' unless data.is_a?(Hash)
-      raise ValidationError, "Invalid apiVersion: expected '#{API_VERSION}'" unless data['apiVersion'] == API_VERSION
-      raise ValidationError, "Invalid kind: expected '#{KIND}'" unless data['kind'] == KIND
-      raise ValidationError, 'Missing required field: contexts' unless data['contexts']
-      raise ValidationError, 'contexts must be an Array' unless data['contexts'].is_a?(Array)
-      raise ValidationError, 'contexts array cannot be empty' if data['contexts'].empty?
+      raise ValidationError, "Config must be a Hash" unless data.is_a?(Hash)
+      raise ValidationError, "Invalid apiVersion: expected '#{API_VERSION}'" unless data["apiVersion"] == API_VERSION
+      raise ValidationError, "Invalid kind: expected '#{KIND}'" unless data["kind"] == KIND
+      raise ValidationError, "Missing required field: contexts" unless data["contexts"]
+      raise ValidationError, "contexts must be an Array" unless data["contexts"].is_a?(Array)
+      raise ValidationError, "contexts array cannot be empty" if data["contexts"].empty?
 
       # Validate each context
-      data['contexts'].each_with_index do |ctx, index|
+      data["contexts"].each_with_index do |ctx, index|
         raise ValidationError, "Context at index #{index} must be a Hash" unless ctx.is_a?(Hash)
-        raise ValidationError, "Context at index #{index} missing 'name'" unless ctx['name']
-        raise ValidationError, "Context at index #{index} missing 'dataDir'" unless ctx['dataDir']
+        raise ValidationError, "Context at index #{index} missing 'name'" unless ctx["name"]
+        raise ValidationError, "Context at index #{index} missing 'dataDir'" unless ctx["dataDir"]
       end
 
       # Check for duplicate context names
-      names = data['contexts'].map { |ctx| ctx['name'] }
+      names = data["contexts"].map { |ctx| ctx["name"] }
       duplicates = names.select { |name| names.count(name) > 1 }.uniq
       raise ValidationError, "Duplicate context names: #{duplicates.join(', ')}" unless duplicates.empty?
     end

data/lib/walheim/handler_registry.rb

@@ -50,6 +50,32 @@ 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
+          handler_class.operation_info.each_key { |op| ops[op] = true } if handler_class.respond_to?(:operation_info)
+        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

@@ -1,19 +1,46 @@
 # frozen_string_literal: true
 
-require_relative 'resource'
+require_relative "resource"
 
 module Walheim
   # NamespacedResource represents resources that are scoped to a namespace
   # 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)
       manifest_data = if manifest_source
-        File.read(manifest_source)
+                        File.read(manifest_source)
       else
-        read_manifest_from_db(namespace, name)
+                        read_manifest_from_db(namespace, name)
       end
 
       if resource_exists?(namespace, name)
@@ -78,7 +105,7 @@ module Walheim
         # Get single resource
         get_single_resource(namespace, name)
       else
-        raise ArgumentError, 'namespace is required when name is specified'
+        raise ArgumentError, "namespace is required when name is specified"
       end
     end
 
@@ -92,7 +119,7 @@ module Walheim
 
       manifest_path = File.join(resource_dir(namespace, 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 = {}
@@ -110,7 +137,7 @@ module Walheim
 
     # Path to resource directory: {data_dir}/namespaces/{namespace}/{kind_plural}/{name}/
     def resource_dir(namespace, name)
-      File.join(@data_dir, 'namespaces', namespace, self.class.kind_info[:plural], name)
+      File.join(@data_dir, "namespaces", namespace, self.class.kind_info[:plural], name)
     end
 
     def resource_exists?(namespace, name)
@@ -142,7 +169,7 @@ module Walheim
     end
 
     def list_single_namespace(namespace)
-      namespaces_dir = File.join(@data_dir, 'namespaces')
+      namespaces_dir = File.join(@data_dir, "namespaces")
       namespace_path = File.join(namespaces_dir, namespace)
 
       unless Dir.exist?(namespace_path)
@@ -155,7 +182,10 @@ module Walheim
 
       # Find all resource directories
       resource_names = Dir.entries(resources_path)
-                          .select { |entry| File.directory?(File.join(resources_path, entry)) && !entry.start_with?('.') }
+                          .select do |entry|
+        File.directory?(File.join(resources_path,
+                                  entry)) && !entry.start_with?(".")
+      end
                           .sort
 
       # Return array of manifest hashes
@@ -165,13 +195,16 @@ module Walheim
     end
 
     def list_all_namespaces
-      namespaces_dir = File.join(@data_dir, 'namespaces')
+      namespaces_dir = File.join(@data_dir, "namespaces")
       return [] unless Dir.exist?(namespaces_dir)
 
       # Find all namespaces
       namespace_names = Dir.entries(namespaces_dir)
-                           .select { |entry| File.directory?(File.join(namespaces_dir, entry)) && !entry.start_with?('.') }
-                           .select { |entry| File.exist?(File.join(namespaces_dir, entry, '.namespace.yaml')) }
+                           .select do |entry|
+        File.directory?(File.join(namespaces_dir,
+                                  entry)) && !entry.start_with?(".")
+      end
+                           .select { |entry| File.exist?(File.join(namespaces_dir, entry, ".namespace.yaml")) }
                            .sort
 
       # Collect all resources from all namespaces
@@ -181,7 +214,10 @@ module Walheim
         next unless Dir.exist?(resources_path)
 
         resource_names = Dir.entries(resources_path)
-                            .select { |entry| File.directory?(File.join(resources_path, entry)) && !entry.start_with?('.') }
+                            .select do |entry|
+          File.directory?(File.join(resources_path,
+                                    entry)) && !entry.start_with?(".")
+        end
                             .sort
 
         resource_names.each do |resource_name|
@@ -189,7 +225,7 @@ module Walheim
         end
       end
 
-      all_resources.sort_by { |resource| [resource[:namespace], resource[:name]] }
+      all_resources.sort_by { |resource| [ resource[:namespace], resource[:name] ] }
     end
   end
 end

data/lib/walheim/resource.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'fileutils'
-require 'terminal-table'
+require "yaml"
+require "fileutils"
+require "terminal-table"
 
 module Walheim
   # Base Resource class containing common functionality for all resource types
@@ -18,7 +18,7 @@ module Walheim
 
     # Metadata - must be overridden by subclasses
     def self.kind_info
-      raise NotImplementedError, 'Subclass must implement kind_info'
+      raise NotImplementedError, "Subclass must implement kind_info"
     end
 
     # Lifecycle hooks - can be overridden by subclasses
@@ -32,7 +32,7 @@ module Walheim
 
     # Summary fields for get output - can be overridden by subclasses
     def self.summary_fields
-      {}  # Default: no summary fields
+      {} # Default: no summary fields
     end
 
     # Operation metadata - defines how operations appear in help
@@ -40,20 +40,25 @@ module Walheim
     def self.operation_info
       {
         get: {
-          description: 'List or retrieve resources',
+          description: "List or retrieve resources",
           usage: [
             "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}"]
+          description: "Create or update a resource",
+          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}"]
+          description: "Delete a resource",
+          usage: [ "delete #{kind_info[:singular]} {name} -n {namespace}" ],
+          options: {}  # Subclasses will override
         }
       }
     end