walheim 0.1.2

data/lib/walheim/cluster_resource.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+
+module Walheim
+  # ClusterResource represents resources that are cluster-scoped (not namespaced)
+  # Examples: Namespaces themselves
+  # These resources typically live at the top level (e.g., namespaces/{name}/)
+  class ClusterResource < Resource
+    # Get operation for cluster-scoped resources
+    # Returns list of all resources (no namespace filtering)
+    def get(name: nil)
+      if name.nil?
+        # List all cluster resources
+        list_all
+      else
+        # Get single cluster resource
+        get_single_resource(name)
+      end
+    end
+
+    # Create a cluster-scoped resource
+    def create(name:, manifest:)
+      # Validate manifest if validator exists
+      validate_manifest(manifest, name) if respond_to?(:validate_manifest, true)
+
+      # Create directory structure
+      ensure_resource_dir(name)
+
+      # Write manifest
+      write_manifest(name, manifest)
+
+      puts "Created #{self.class.kind_info[:singular]} '#{name}'"
+
+      # POST-CREATE HOOK
+      trigger_hook(:post_create, name: name)
+    end
+
+    # Update a cluster-scoped resource
+    def update(name:, manifest:)
+      # Validate manifest if validator exists
+      validate_manifest(manifest, name) if respond_to?(:validate_manifest, true)
+
+      # Write manifest (overwrite)
+      write_manifest(name, manifest)
+
+      puts "Updated #{self.class.kind_info[:singular]} '#{name}'"
+
+      # POST-UPDATE HOOK
+      trigger_hook(:post_update, name: name)
+    end
+
+    # Delete a cluster-scoped resource
+    def delete(name:)
+      unless resource_exists?(name)
+        warn "Error: #{self.class.kind_info[:singular]} '#{name}' not found"
+        exit 1
+      end
+
+      # PRE-DELETE HOOK
+      trigger_hook(:pre_delete, name: name)
+
+      # Delete from filesystem
+      remove_resource_dir(name)
+
+      puts "Deleted #{self.class.kind_info[:singular]} '#{name}'"
+    end
+
+    # Apply operation - create or update
+    def apply(name:, manifest_source: nil)
+      manifest_data = if manifest_source
+        File.read(manifest_source)
+      else
+        read_manifest_from_db(name)
+      end
+
+      if resource_exists?(name)
+        update(name: name, manifest: manifest_data)
+      else
+        create(name: name, manifest: manifest_data)
+      end
+    end
+
+    private
+
+    def get_single_resource(name)
+      unless resource_exists?(name)
+        warn "Error: #{self.class.kind_info[:singular]} '#{name}' not found"
+        exit 1
+      end
+
+      manifest_path = File.join(resource_dir(name), manifest_filename)
+      manifest_content = File.read(manifest_path)
+      manifest_data = YAML.load(manifest_content)
+
+      # Compute summary fields
+      summary = {}
+      self.class.summary_fields.each do |field_name, compute_fn|
+        summary[field_name] = compute_fn.call(manifest_data)
+      end
+
+      {
+        name: name,
+        manifest: manifest_data,
+        summary: summary
+      }
+    end
+
+    def list_all
+      base_dir = File.join(@data_dir, self.class.kind_info[:plural])
+      return [] unless Dir.exist?(base_dir)
+
+      # Find all resource directories
+      resource_names = find_resource_names
+
+      # Return array of resource hashes
+      resource_names.map do |name|
+        get_single_resource(name)
+      end
+    end
+
+    # Override in subclasses to customize how resources are discovered
+    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.exist?(File.join(base_dir, entry, manifest_filename)) }
+         .sort
+    end
+
+    # Path to resource directory (cluster resources: {data_dir}/{kind_plural}/{name}/)
+    # For namespaces: {data_dir}/namespaces/{name}/
+    # For appsets: {data_dir}/appsets/{name}/
+    def resource_dir(name)
+      File.join(@data_dir, self.class.kind_info[:plural], name)
+    end
+
+    def resource_exists?(name)
+      manifest_path = File.join(resource_dir(name), manifest_filename)
+      File.exist?(manifest_path)
+    end
+
+    def ensure_resource_dir(name)
+      FileUtils.mkdir_p(resource_dir(name))
+    end
+
+    def write_manifest(name, manifest)
+      path = File.join(resource_dir(name), manifest_filename)
+      File.write(path, manifest)
+    end
+
+    def read_manifest_from_db(name)
+      path = File.join(resource_dir(name), manifest_filename)
+      unless File.exist?(path)
+        warn "Error: No manifest found at #{path}"
+        warn "Use 'whctl apply -f <file>' to create from a manifest file"
+        exit 1
+      end
+      File.read(path)
+    end
+
+    def remove_resource_dir(name)
+      FileUtils.rm_rf(resource_dir(name))
+    end
+  end
+end

data/lib/walheim/config.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module Walheim
+  # Configuration management for Walheim contexts
+  # Handles reading/writing ~/.walheim/config with support for $WHCONFIG override
+  class Config
+    class ConfigError < StandardError; end
+    class ValidationError < ConfigError; end
+
+    DEFAULT_CONFIG_PATH = File.expand_path('~/.walheim/config')
+    API_VERSION = 'walheim.io/v1'
+    KIND = 'Config'
+
+    attr_reader :current_context, :contexts, :config_path
+
+    # Initialize a new Config instance
+    #
+    # @param config_path [String, nil] Path to config file (defaults to ~/.walheim/config or $WHCONFIG)
+    def initialize(config_path: nil)
+      @config_path = resolve_config_path(config_path)
+      @current_context = nil
+      @contexts = []
+      load_config if File.exist?(@config_path)
+    end
+
+    # Load configuration from file
+    #
+    # @return [void]
+    # @raise [ConfigError] if file cannot be read or parsed
+    # @raise [ValidationError] if config structure is invalid
+    def load_config
+      data = YAML.load_file(@config_path)
+      validate_schema!(data)
+
+      @current_context = data['currentContext']
+      @contexts = data['contexts'].map do |ctx|
+        {
+          '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
+      raise ConfigError, "Failed to load config: #{e.message}"
+    end
+
+    # Save configuration to file (atomic write)
+    #
+    # @return [void]
+    # @raise [ConfigError] if file cannot be written
+    def save_config
+      data = {
+        'apiVersion' => API_VERSION,
+        'kind' => KIND,
+        'currentContext' => @current_context,
+        'contexts' => @contexts.map do |ctx|
+          {
+            'name' => ctx['name'],
+            'dataDir' => ctx['dataDir']
+          }
+        end
+      }
+
+      # Atomic write: write to temp file, then rename
+      dir = File.dirname(@config_path)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+      temp_file = "#{@config_path}.tmp.#{Process.pid}"
+      File.write(temp_file, YAML.dump(data))
+      File.rename(temp_file, @config_path)
+    rescue => e
+      File.delete(temp_file) if temp_file && File.exist?(temp_file)
+      raise ConfigError, "Failed to save config: #{e.message}"
+    end
+
+    # Get the data directory for a context
+    #
+    # @param context_name [String, nil] Context name (defaults to current context)
+    # @return [String] Path to data directory
+    # @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?
+
+      context = find_context(name)
+      raise ConfigError, "Context '#{name}' not found" if context.nil?
+
+      context['dataDir']
+    end
+
+    # Add a new context
+    #
+    # @param name [String] Context name
+    # @param data_dir [String] Path to data directory
+    # @param activate [Boolean] Whether to activate this context immediately
+    # @return [void]
+    # @raise [ValidationError] if context name already exists
+    def add_context(name, data_dir, activate: true)
+      raise ValidationError, "Context '#{name}' already exists" if find_context(name)
+
+      @contexts << {
+        'name' => name,
+        'dataDir' => expand_path(data_dir)
+      }
+
+      @current_context = name if activate
+    end
+
+    # Remove a context
+    #
+    # @param name [String] Context name
+    # @return [void]
+    # @raise [ConfigError] if context not found
+    def delete_context(name)
+      context = find_context(name)
+      raise ConfigError, "Context '#{name}' not found" if context.nil?
+
+      @contexts.delete(context)
+
+      # If we deleted the active context, clear it
+      @current_context = nil if @current_context == name
+    end
+
+    # Switch to a different context
+    #
+    # @param name [String] Context name
+    # @return [void]
+    # @raise [ConfigError] if context not found
+    def use_context(name)
+      raise ConfigError, "Context '#{name}' not found" unless find_context(name)
+      @current_context = name
+    end
+
+    # List all contexts
+    #
+    # @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)
+      end
+    end
+
+    # Check if config file exists
+    #
+    # @return [Boolean]
+    def self.exists?(config_path: nil)
+      path = new(config_path: config_path).config_path
+      File.exist?(path)
+    end
+
+    private
+
+    # 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']
+      DEFAULT_CONFIG_PATH
+    end
+
+    # Expand path with ~ support
+    def expand_path(path)
+      File.expand_path(path)
+    end
+
+    # Find a context by name
+    def find_context(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?
+
+      # Validate each context
+      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']
+      end
+
+      # Check for duplicate context names
+      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
+
+    # Validate that current context (if set) exists in contexts array
+    def validate_current_context!
+      return if @current_context.nil?
+      return if find_context(@current_context)
+
+      raise ValidationError, "Current context '#{@current_context}' not found in contexts"
+    end
+  end
+end

data/lib/walheim/handler_registry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Walheim
+  class HandlerRegistry
+    class << self
+      def handlers
+        @handlers ||= {}
+      end
+
+      def register(kind:, plural:, singular:, handler_class:, aliases: [])
+        # Register plural (visible in listings)
+        handlers[plural] = {
+          handler: handler_class,
+          name: plural,
+          visible: true,
+          info: handler_class.kind_info
+        }
+
+        # Register singular (not visible)
+        handlers[singular] = {
+          handler: handler_class,
+          name: plural,
+          visible: false,
+          info: handler_class.kind_info
+        }
+
+        # Register aliases (not visible)
+        aliases.each do |alias_name|
+          handlers[alias_name] = {
+            handler: handler_class,
+            name: plural,
+            visible: false,
+            info: handler_class.kind_info
+          }
+        end
+      end
+
+      def get(kind)
+        handlers[kind]
+      end
+
+      def all_visible
+        handlers.values.select { |h| h[:visible] }.uniq { |h| h[:name] }.sort_by { |h| h[:name] }
+      end
+
+      def supports_operation?(kind, operation)
+        handler_info = get(kind)
+        return false unless handler_info
+
+        handler_class = handler_info[:handler]
+        handler_class.public_instance_methods.include?(operation.to_sym)
+      end
+    end
+  end
+end

data/lib/walheim/namespaced_resource.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+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
+    # CRUD operations for namespace-scoped resources
+
+    def apply(namespace:, name:, manifest_source: nil)
+      manifest_data = if manifest_source
+        File.read(manifest_source)
+      else
+        read_manifest_from_db(namespace, name)
+      end
+
+      if resource_exists?(namespace, name)
+        update(namespace: namespace, name: name, manifest: manifest_data)
+      else
+        create(namespace: namespace, name: name, manifest: manifest_data)
+      end
+    end
+
+    def create(namespace:, name:, manifest:)
+      # Validate manifest if validator exists
+      validate_manifest(manifest, namespace, name) if respond_to?(:validate_manifest, true)
+
+      # Create directory structure
+      ensure_resource_dir(namespace, name)
+
+      # Write manifest to DB
+      write_manifest(namespace, name, manifest)
+
+      puts "Created #{self.class.kind_info[:singular]} '#{name}' in namespace '#{namespace}'"
+
+      # POST-CREATE HOOK
+      trigger_hook(:post_create, namespace: namespace, name: name)
+    end
+
+    def update(namespace:, name:, manifest:)
+      # Validate manifest if validator exists
+      validate_manifest(manifest, namespace, name) if respond_to?(:validate_manifest, true)
+
+      # Write manifest to DB (overwrite)
+      write_manifest(namespace, name, manifest)
+
+      puts "Updated #{self.class.kind_info[:singular]} '#{name}' in namespace '#{namespace}'"
+
+      # POST-UPDATE HOOK
+      trigger_hook(:post_update, namespace: namespace, name: name)
+    end
+
+    def delete(namespace:, name:)
+      unless resource_exists?(namespace, name)
+        warn "Error: #{self.class.kind_info[:singular]} '#{name}' not found"
+        exit 1
+      end
+
+      # PRE-DELETE HOOK
+      trigger_hook(:pre_delete, namespace: namespace, name: name)
+
+      # Delete from DB
+      remove_resource_dir(namespace, name)
+
+      puts "Deleted #{self.class.kind_info[:singular]} '#{name}' from namespace '#{namespace}'"
+    end
+
+    def get(namespace:, name: nil)
+      if namespace.nil? && name.nil?
+        # List all resources across all namespaces
+        list_all_namespaces
+      elsif namespace && name.nil?
+        # List resources in a single namespace
+        list_single_namespace(namespace)
+      elsif namespace && name
+        # Get single resource
+        get_single_resource(namespace, name)
+      else
+        raise ArgumentError, 'namespace is required when name is specified'
+      end
+    end
+
+    private
+
+    def get_single_resource(namespace, name)
+      unless resource_exists?(namespace, name)
+        warn "Error: #{self.class.kind_info[:singular]} '#{name}' not found in namespace '#{namespace}'"
+        exit 1
+      end
+
+      manifest_path = File.join(resource_dir(namespace, name), manifest_filename)
+      manifest_content = File.read(manifest_path)
+      manifest_data = YAML.load(manifest_content)
+
+      # Compute summary fields
+      summary = {}
+      self.class.summary_fields.each do |field_name, compute_fn|
+        summary[field_name] = compute_fn.call(manifest_data)
+      end
+
+      {
+        namespace: namespace,
+        name: name,
+        manifest: manifest_data,
+        summary: summary
+      }
+    end
+
+    # 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)
+    end
+
+    def resource_exists?(namespace, name)
+      manifest_path = File.join(resource_dir(namespace, name), manifest_filename)
+      File.exist?(manifest_path)
+    end
+
+    def ensure_resource_dir(namespace, name)
+      FileUtils.mkdir_p(resource_dir(namespace, name))
+    end
+
+    def write_manifest(namespace, name, manifest)
+      path = File.join(resource_dir(namespace, name), manifest_filename)
+      File.write(path, manifest)
+    end
+
+    def read_manifest_from_db(namespace, name)
+      path = File.join(resource_dir(namespace, name), manifest_filename)
+      unless File.exist?(path)
+        warn "Error: No manifest found at #{path}"
+        warn "Use 'whctl apply -f <file>' to create from a manifest file"
+        exit 1
+      end
+      File.read(path)
+    end
+
+    def remove_resource_dir(namespace, name)
+      FileUtils.rm_rf(resource_dir(namespace, name))
+    end
+
+    def list_single_namespace(namespace)
+      namespaces_dir = File.join(@data_dir, 'namespaces')
+      namespace_path = File.join(namespaces_dir, namespace)
+
+      unless Dir.exist?(namespace_path)
+        warn "Error: namespace '#{namespace}' not found"
+        exit 1
+      end
+
+      resources_path = File.join(namespace_path, self.class.kind_info[:plural])
+      return [] unless Dir.exist?(resources_path)
+
+      # Find all resource directories
+      resource_names = Dir.entries(resources_path)
+                          .select { |entry| File.directory?(File.join(resources_path, entry)) && !entry.start_with?('.') }
+                          .sort
+
+      # Return array of manifest hashes
+      resource_names.map do |name|
+        get_single_resource(namespace, name)
+      end
+    end
+
+    def list_all_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')) }
+                           .sort
+
+      # Collect all resources from all namespaces
+      all_resources = []
+      namespace_names.each do |namespace|
+        resources_path = File.join(namespaces_dir, namespace, self.class.kind_info[:plural])
+        next unless Dir.exist?(resources_path)
+
+        resource_names = Dir.entries(resources_path)
+                            .select { |entry| File.directory?(File.join(resources_path, entry)) && !entry.start_with?('.') }
+                            .sort
+
+        resource_names.each do |resource_name|
+          all_resources << get_single_resource(namespace, resource_name)
+        end
+      end
+
+      all_resources.sort_by { |resource| [resource[:namespace], resource[:name]] }
+    end
+  end
+end

data/lib/walheim/resource.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+require 'terminal-table'
+
+module Walheim
+  # Base Resource class containing common functionality for all resource types
+  # Subclasses:
+  # - NamespacedResource: for namespace-scoped resources (apps, secrets, configmaps)
+  # - ClusterResource: for cluster-scoped resources (namespaces)
+  class Resource
+    attr_reader :data_dir
+
+    def initialize(data_dir: Dir.pwd)
+      @data_dir = data_dir
+    end
+
+    # Metadata - must be overridden by subclasses
+    def self.kind_info
+      raise NotImplementedError, 'Subclass must implement kind_info'
+    end
+
+    # Lifecycle hooks - can be overridden by subclasses
+    def self.hooks
+      {
+        post_create: nil,    # Method name to call after create
+        post_update: nil,    # Method name to call after update
+        pre_delete: nil      # Method name to call before delete
+      }
+    end
+
+    # Summary fields for get output - can be overridden by subclasses
+    def self.summary_fields
+      {}  # Default: no summary fields
+    end
+
+    # Operation metadata - defines how operations appear in help
+    # Subclasses can override to add custom operations
+    def self.operation_info
+      {
+        get: {
+          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}"
+          ]
+        },
+        apply: {
+          description: 'Create or update a resource',
+          usage: ["apply #{kind_info[:singular]} {name} -n {namespace}"]
+        },
+        delete: {
+          description: 'Delete a resource',
+          usage: ["delete #{kind_info[:singular]} {name} -n {namespace}"]
+        }
+      }
+    end
+
+    protected
+
+    # Trigger lifecycle hooks
+    def trigger_hook(hook_type, **kwargs)
+      hook_method = self.class.hooks[hook_type]
+      return unless hook_method
+
+      send(hook_method, **kwargs)
+    end
+
+    # Default manifest filename - subclasses can override
+    def manifest_filename
+      "#{self.class.kind_info[:singular]}.yaml"
+    end
+  end
+end