moose-inventory 1.0.9 → 2.1

data/lib/moose_inventory/cli/association_rendering.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'association_rendering_support'
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared rendering helpers for host/group association commands.
+      module AssociationRendering
+        include Moose::Inventory::Cli::AssociationRenderingSupport
+
+        private
+
+        def host_group_association_addition_emitter(perspective:)
+          lambda do |event|
+            render_host_group_association_addition_event(event, perspective:)
+          end
+        end
+
+        def host_group_association_removal_emitter(perspective:)
+          lambda do |event|
+            render_host_group_association_removal_event(event, perspective:)
+          end
+        end
+
+        def render_host_group_association_addition_event(event, perspective:)
+          payload = event.payload
+
+          return render_addition_warning(event.type, payload, perspective:) if addition_warning_event?(event.type)
+          return render_addition_existing(payload, perspective:) if event.type == :already_exists_skipping
+          return render_association_dry_run_summary if event.type == :dry_run_summary
+
+          render_addition_action_event(event.type, payload, perspective:)
+        end
+
+        def render_addition_action_event(type, payload, perspective:)
+          case type
+          when :adding_host_group_association, :adding_group_host_association
+            fmt.puts 2, "- #{verb_for(:add, perspective)} association #{association_label(payload, perspective:)}..."
+          when :group_creating_now, :host_creating_now
+            fmt.puts 4, "- #{missing_entity_label(perspective)} does not exist, creating now..."
+          when :removing_automatic_group
+            label = automatic_group_label(payload[:host], perspective:)
+            fmt.puts 2, "- #{verb_for(:remove, perspective)} automatic association #{label}..."
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+
+        def render_association_dry_run_summary
+          puts 'Dry run complete. No changes applied.'
+        end
+
+        def render_host_group_association_removal_event(event, perspective:)
+          payload = event.payload
+
+          return render_removal_warning(payload, perspective:) if removal_warning_event?(event.type)
+          return render_removal_missing(payload, perspective:) if event.type == :missing_skipping
+          return render_association_dry_run_summary if event.type == :dry_run_summary
+
+          case event.type
+          when :removing_host_group_association, :removing_group_host_association
+            fmt.puts 2, "- #{verb_for(:remove, perspective)} association #{association_label(payload, perspective:)}..."
+          when :adding_automatic_group
+            label = automatic_group_label(payload[:host], perspective:)
+            fmt.puts 2, "- #{verb_for(:add, perspective)} automatic association #{label}..."
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/association_rendering_support.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared string helpers for host/group association commands.
+      module AssociationRenderingSupport
+        private
+
+        def addition_warning_event?(type)
+          %i[
+            host_group_association_exists
+            group_host_association_exists
+            group_missing_created
+            host_missing_created
+          ].include?(type)
+        end
+
+        def removal_warning_event?(type)
+          %i[host_group_association_missing group_host_association_missing].include?(type)
+        end
+
+        def render_addition_warning(type, payload, perspective:)
+          if %i[host_group_association_exists group_host_association_exists].include?(type)
+            fmt.warn warning_text(
+              "Association #{association_label(payload, perspective:)} already exists, skipping.",
+              perspective:
+            )
+          else
+            fmt.warn warning_text(
+              "#{missing_entity_label(perspective).capitalize} '#{payload[:name]}' does not exist and will be created.",
+              perspective:
+            )
+          end
+        end
+
+        def render_addition_existing(payload, perspective:)
+          fmt.puts payload[:indent], "- #{existing_status_text(perspective)}"
+        end
+
+        def render_removal_warning(payload, perspective:)
+          fmt.warn "Association #{association_label(payload, perspective:)} doesn't exist, skipping.\n"
+        end
+
+        def render_removal_missing(payload, perspective:)
+          fmt.puts payload[:indent], "- #{missing_status_text(perspective)}"
+        end
+
+        def association_label(payload, perspective:)
+          if perspective == :host
+            "{host:#{payload[:host]} <-> group:#{payload[:group]}}"
+          else
+            "{group:#{payload[:group]} <-> host:#{payload[:host]}}"
+          end
+        end
+
+        def automatic_group_label(host, perspective:)
+          if perspective == :host
+            "{host:#{host} <-> group:ungrouped}"
+          else
+            "{group:ungrouped <-> host:#{host}}"
+          end
+        end
+
+        def verb_for(action, perspective)
+          return action.to_s.capitalize if perspective == :host
+
+          action.to_s
+        end
+
+        def missing_entity_label(perspective)
+          perspective == :host ? 'Group' : 'host'
+        end
+
+        def existing_status_text(perspective)
+          perspective == :host ? 'Already exists, skipping.' : 'already exists, skipping.'
+        end
+
+        def missing_status_text(perspective)
+          perspective == :host ? "Doesn't exist, skipping." : "doesn't exist, skipping."
+        end
+
+        def warning_text(text, perspective:)
+          perspective == :host ? text : "#{text}\n"
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/audit.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'thor'
+
+module Moose
+  module Inventory
+    module Cli
+      # Audit log inspection commands.
+      class Audit < Thor
+        include Moose::Inventory::Cli::Helpers
+
+        desc 'list', 'List recent append-only audit events'
+        option :limit, type: :numeric, default: 20
+        option :format, type: :string, desc: 'Emit audit events as yaml|json|pjson'
+        def list
+          events = inventory_context.audit_events(limit: options[:limit]).map { |event| serialize_event(event) }
+          if options[:format]
+            fmt.dump(events, options[:format].downcase)
+          else
+            render_human_events(events)
+          end
+        end
+
+        private
+
+        def serialize_event(event)
+          {
+            id: event.id,
+            created_at: event.created_at,
+            actor: event.actor,
+            command: event.command,
+            action: event.action,
+            entity_type: event.entity_type,
+            entity_name: event.entity_name,
+            details: parse_details(event.details)
+          }
+        end
+
+        def parse_details(details)
+          return nil if details.nil? || details.empty?
+
+          JSON.parse(details)
+        rescue JSON::ParserError
+          details
+        end
+
+        def render_human_events(events)
+          if events.empty?
+            puts 'No audit events recorded.'
+            return
+          end
+
+          events.each do |event|
+            puts "#{event[:id]} #{event[:created_at]} #{event[:command]} " \
+                 "#{event[:entity_type]}=#{event[:entity_name]} action=#{event[:action]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/audit_recording.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared append-only audit recording helpers for mutating CLI commands.
+      module AuditRecording
+        private
+
+        def record_audit(metadata, result:, dry_run: false)
+          return if dry_run
+
+          inventory_context.record_audit_event(
+            command: metadata.fetch(:command),
+            action: metadata.fetch(:action),
+            actor: ENV.fetch('USER', nil),
+            entity_type: metadata.fetch(:entity_type),
+            entity_name: Array(metadata.fetch(:entity_names)).join(','),
+            details: audit_details(result)
+          )
+        end
+
+        def audit_details(result)
+          JSON.generate(
+            warning_count: result.respond_to?(:warning_count) ? result.warning_count : 0,
+            events: audit_events_from_result(result)
+          )
+        end
+
+        def audit_events_from_result(result)
+          return [] unless result.respond_to?(:events)
+
+          result.events.map { |event| { type: event.type, payload: event.payload } }
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/child_relation_rendering.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Moose
+  module Inventory
+    module Cli
+      # Shared rendering helpers for child-group relation commands.
+      module ChildRelationRendering
+        private
+
+        def addchild_emitter
+          lambda do |event|
+            render_addchild_event(event)
+          end
+        end
+
+        def rmchild_emitter
+          lambda do |event|
+            render_rmchild_event(event)
+          end
+        end
+
+        def render_addchild_event(event)
+          payload = event.payload
+
+          return render_addchild_warning(event.type, payload) if addchild_warning?(event.type)
+          return render_addchild_existing(payload) if event.type == :already_exists_skipping
+          return render_child_relation_dry_run_summary if event.type == :dry_run_summary
+
+          case event.type
+          when :adding_child_association
+            fmt.puts 2, "- add association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          when :child_group_creating_now
+            fmt.puts 4, '- child group does not exist, creating now...'
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+
+        def render_child_relation_dry_run_summary
+          puts 'Dry run complete. No changes applied.'
+        end
+
+        def addchild_warning?(type)
+          %i[child_association_exists child_group_missing].include?(type)
+        end
+
+        def render_addchild_warning(type, payload)
+          if type == :child_association_exists
+            fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}} already exists, skipping.\n"
+          else
+            fmt.warn "Group '#{payload[:name]}' does not exist and will be created.\n"
+          end
+        end
+
+        def render_addchild_existing(payload)
+          fmt.puts payload[:indent], '- already exists, skipping.'
+        end
+
+        def render_rmchild_event(event)
+          payload = event.payload
+
+          return render_rmchild_warning(payload) if event.type == :child_association_missing
+          return render_rmchild_missing(payload) if event.type == :missing_skipping
+          return render_rmchild_progress(event.type, payload) if rmchild_progress_event?(event.type)
+          return render_child_relation_dry_run_summary if event.type == :dry_run_summary
+
+          render_rmchild_status(event.type, payload)
+        end
+
+        def rmchild_progress_event?(type)
+          %i[
+            removing_child_association
+            recursively_delete_orphaned_group
+            removing_recursive_child_association
+          ].include?(type)
+        end
+
+        def render_rmchild_progress(type, payload)
+          case type
+          when :removing_child_association
+            fmt.puts 2, "- remove association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          when :recursively_delete_orphaned_group
+            fmt.puts 2, "- Recursively delete orphaned group '#{payload[:name]}'..."
+          when :removing_recursive_child_association
+            fmt.puts 4, "- Remove association {group:#{payload[:parent]} <-> group:#{payload[:child]}}..."
+          end
+        end
+
+        def render_rmchild_status(type, payload)
+          case type
+          when :adding_automatic_group_to_host
+            fmt.puts payload[:indent], "- Adding automatic association {group:ungrouped <-> host:#{payload[:host]}}..."
+          when :destroying_group
+            fmt.puts payload[:indent], "- Destroy group '#{payload[:name]}'..."
+          when :ok
+            fmt.puts payload[:indent], '- OK'
+          end
+        end
+
+        def render_rmchild_warning(payload)
+          fmt.warn "Association {group:#{payload[:parent]} <-> group:#{payload[:child]}} does not exist, skipping.\n"
+        end
+
+        def render_rmchild_missing(payload)
+          fmt.puts payload[:indent], "- doesn't exist, skipping."
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/console.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Moose
+  module Inventory
+    module Cli
+      # Small read-only interactive console for browsing inventory state.
+      class Console
+        COMMANDS = ['help', 'hosts', 'groups', 'host NAME', 'group NAME',
+                    'tags host NAME', 'tags group NAME', 'audit [LIMIT]', 'quit'].freeze
+
+        def initialize(context:, input: $stdin, output: $stdout)
+          @context = context
+          @input = input
+          @output = output
+        end
+
+        def run
+          output.puts 'Moose Inventory console (read-only). Type help or quit.'
+          input.each_line do |line|
+            parts = parse_command(line)
+            next if parts.nil? || parts.empty?
+
+            break if quit_command?(parts)
+
+            dispatch(parts)
+          end
+          output.puts 'Goodbye.'
+        end
+
+        private
+
+        attr_reader :context, :input, :output
+
+        def parse_command(line)
+          command = line.strip
+          return [] if command.empty?
+
+          Shellwords.split(command)
+        rescue ArgumentError => e
+          output.puts "Invalid command syntax: #{e.message}"
+          nil
+        end
+
+        def dispatch(parts)
+          handlers = {
+            'help' => -> { render_exact(parts, 'help') { render_help } },
+            'hosts' => -> { render_exact(parts, 'hosts') { render_hosts } },
+            'groups' => -> { render_exact(parts, 'groups') { render_groups } },
+            'host' => -> { render_entity(:host, parts) },
+            'group' => -> { render_entity(:group, parts) },
+            'tags' => -> { render_tags(parts) },
+            'audit' => -> { render_audit(parts) }
+          }
+          handlers.fetch(parts.first, -> { output.puts "Unknown command: #{parts.join(' ')}" }).call
+        end
+
+        def quit_command?(parts)
+          parts.length == 1 && %w[quit exit].include?(parts.first)
+        end
+
+        def render_exact(parts, usage)
+          return output.puts("Usage: #{usage}") unless parts.length == 1
+
+          yield
+        end
+
+        def render_help
+          output.puts 'Commands:'
+          COMMANDS.each { |command| output.puts "- #{command}" }
+        end
+
+        def render_hosts
+          names = context.all_hosts.map(&:name).sort
+          output.puts(names.empty? ? 'No hosts.' : "Hosts: #{names.join(', ')}")
+        end
+
+        def render_groups
+          names = context.all_groups.map(&:name).sort
+          output.puts(names.empty? ? 'No groups.' : "Groups: #{names.join(', ')}")
+        end
+
+        def render_entity(type, parts)
+          return output.puts("Usage: #{type} NAME") unless parts.length == 2
+
+          name = parts[1]
+
+          entity = context.public_send("find_#{type}", name)
+          return output.puts("#{type.capitalize} '#{name}' not found.") if entity.nil?
+
+          output.puts "#{type.capitalize}: #{name}"
+          output.puts "Groups: #{entity.groups_dataset.map(:name).sort.join(', ')}" if type == :host
+          output.puts "Hosts: #{entity.hosts_dataset.map(:name).sort.join(', ')}" if type == :group
+          output.puts "Tags: #{entity.tags_dataset.map(:name).sort.join(', ')}"
+        end
+
+        def render_tags(parts)
+          type = parts[1]
+          name = parts[2]
+          return output.puts('Usage: tags host|group NAME') unless parts.length == 3 && %w[host group].include?(type)
+
+          entity = context.public_send("find_#{type}", name)
+          return output.puts("#{type.capitalize} '#{name}' not found.") if entity.nil?
+
+          tags = entity.tags_dataset.map(:name).sort
+          output.puts tags.empty? ? "#{type.capitalize} '#{name}' has no tags." : tags.join(', ')
+        end
+
+        def render_audit(parts)
+          limit = audit_limit(parts[1]) if parts.length <= 2
+          return output.puts('Usage: audit [LIMIT]') if parts.length > 2 || limit.nil?
+
+          events = context.audit_events(limit: limit)
+          return output.puts('No audit events recorded.') if events.empty?
+
+          events.each do |event|
+            output.puts "#{event.id} #{event.created_at} #{event.command} #{event.entity_type}=#{event.entity_name}"
+          end
+        end
+
+        def audit_limit(value)
+          return 10 if value.nil?
+
+          parsed = Integer(value)
+          return parsed if parsed.positive?
+
+          nil
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/db.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+
+require_relative 'formatter'
+
+module Moose
+  module Inventory
+    module Cli
+      # Database lifecycle commands.
+      class Db < Thor
+        desc 'status', 'Show database lifecycle status'
+        def status
+          render_status(Moose::Inventory::DB.status)
+        end
+
+        desc 'doctor', 'Check database schema state'
+        def doctor
+          status = Moose::Inventory::DB.status
+          missing = status[:tables].reject { |_name, present| present }.keys
+          if missing.empty? && status[:schema_version] == status[:expected_schema_version]
+            puts 'Database doctor found no issues.'
+            return
+          end
+
+          puts 'Database doctor found issue(s):'
+          puts "- Missing tables: #{missing.join(', ')}" unless missing.empty?
+          if status[:schema_version] != status[:expected_schema_version]
+            puts "- Schema version is #{status[:schema_version].inspect}; expected #{status[:expected_schema_version]}."
+          end
+          exit(1)
+        end
+
+        desc 'migrate', 'Create missing schema tables and record current schema version'
+        def migrate
+          status = Moose::Inventory::DB.migrate!
+          puts "Database schema is at version #{status[:schema_version]}."
+        end
+
+        desc 'backup FILE', 'Back up the configured sqlite3 database file'
+        def backup(file)
+          destination = Moose::Inventory::DB.backup(file)
+          puts "Backed up database to #{destination}."
+        rescue Moose::Inventory::DB.exceptions[:moose] => e
+          abort("ERROR: #{e.message}")
+        end
+
+        private
+
+        def render_status(status)
+          puts "Adapter: #{status[:adapter]}"
+          puts "Schema version: #{status[:schema_version] || 'unknown'}"
+          puts "Expected schema version: #{status[:expected_schema_version]}"
+          puts "SQLite file: #{status[:sqlite_file]}" unless status[:sqlite_file].nil?
+          puts 'Tables:'
+          status[:tables].each do |name, present|
+            puts "- #{name}: #{present ? 'present' : 'missing'}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../operations/query_inventory'
+
+module Moose
+  module Inventory
+    module Cli
+      # Small factory for command-side operations and query wrappers.
+      class Factory
+        def initialize(context:)
+          @context = context
+        end
+
+        def operation(operation_class, **)
+          operation_class.new(context: context, **)
+        end
+
+        def query_inventory
+          @query_inventory ||= Moose::Inventory::Operations::QueryInventory.new(context: context)
+        end
+
+        private
+
+        attr_reader :context
+      end
+    end
+  end
+end

data/lib/moose_inventory/cli/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'yaml'
 require 'indentation'
@@ -5,24 +7,18 @@ require 'indentation'
 module Moose
   module Inventory
     module Cli
-      ##
-      # TODO: Documentation
       module Formatter
         # rubocop:disable Style/ModuleFunction
         extend self
         # rubocop:enable Style/ModuleFunction
 
-        def self.dump(arg, format = nil)
+        def self.dump(arg, format = 'json')
           out(arg, format)
         end
 
-        def self.out(arg, format = nil)
+        def self.out(arg, format = 'json')
           return if arg.nil?
 
-          if format.nil?
-            format = Moose::Inventory::Config._confopts[:format].downcase
-          end
-
           case format
           when 'yaml', 'y'
             $stdout.puts arg.to_yaml
@@ -50,7 +46,7 @@ module Moose
           when 'STDOUT'
             $stdout.puts msg.indent(indent)
           when 'STDERR'
-            $stderr.puts msg.indent(indent)
+            $stderr.print("#{msg.indent(indent)}\n")
           else
             abort("Output stream '#{stream}' is not known.")
           end
@@ -67,12 +63,12 @@ module Moose
           end
         end
 
-        def info(_indent, _msg, stream = 'STDOUT')
+        def info(indent, msg, stream = 'STDOUT')
           case stream
           when 'STDOUT'
-            $stdout.print 'INFO: {msg}'
+            $stdout.print "INFO: #{msg}".indent(indent)
           when 'STDERR'
-            $stderr.print 'INFO: {msg}'
+            $stderr.print "INFO: #{msg}".indent(indent)
           else
             abort("Output stream '#{stream}' is not known.")
           end

data/lib/moose_inventory/cli/group.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'thor'
-require_relative './formatter.rb'
+require_relative 'formatter'
+require_relative 'helpers'
 
 module Moose
   module Inventory
@@ -7,6 +10,8 @@ module Moose
       ##
       # Class implementing the "group" methods of the CLI
       class Group < Thor
+        include Moose::Inventory::Cli::Helpers
+
         require_relative 'group_add'
         require_relative 'group_get'
         require_relative 'group_list'
@@ -18,6 +23,7 @@ module Moose
         require_relative 'group_addvar'
         require_relative 'group_listvars'
         require_relative 'group_rmvar'
+        require_relative 'group_tags'
       end
     end
   end