aro 0.1.7 → 0.1.9

data/sys/cli/config.rb

@@ -12,7 +12,7 @@ module CLI
 
   # cli entrypoint
   def self.config
-    Aro::D.say("#{__FILE__}:#{__method__} was called (todo)...")
+    CLI::Config.process_config_command(ARGV)
   end
 
   class Config
@@ -53,41 +53,76 @@ module CLI
       RUBY_FACOT: :ruby_facot,
     }
 
+    # ovar and ivar access
+    #
+    # example usage:
+    # CLI::Config::DEF_ACCESS[:READ]
     DEF_ACCESS = {
       READ: :read,
       WRITE: :write
     }
 
+    BOOLS = {
+      FALSE: false,
+      TRUE: true,
+    }
+
+    TYPES = {
+      BOOL: :bool,
+      INT: :int,
+      STRING: :string,
+      VALUES: :values
+    }
+
     # types used in definition
     # 
     # example usage:
     # CLI::Config::DEF_TYPES[:INT][:validator].call(unvalid, CLI::Config::DEF[:DIMENSION])
     DEF_TYPES = {
+      BOOL: {
+        name: CLI::Config::TYPES[:BOOL],
+        description: I18n.t("cli.config.type.bool_description"),
+        converter: Proc.new{|v|
+          if [CLI::Config::BOOLS[:TRUE].to_s, Aro::Mancy::S].include?(v)
+            CLI::Config::BOOLS[:TRUE]
+          else
+            CLI::Config::BOOLS[:FALSE]
+          end
+        },
+        validator: Proc.new{|unvalid, k, v|
+          CLI::Config.def_valid?(k, v) &&
+          CLI::Config.bool_valid?(unvalid)
+        }
+      },
       INT: {
         name: :int,
-        description: I18n.t("cli.config.type_int_description"),
+        description: I18n.t("cli.config.type.int_description"),
+        converter: Proc.new{|v| v.to_i},
         validator: Proc.new{|unvalid, k, v|
+          Aro::V.say("validating #{k} (#{CLI::Config::DEF_TYPES[:INT][:name]})")
+          Aro::V.say("unvalid = #{unvalid}")
+          Aro::V.say("[min, max] = [#{v[:min]}, #{v[:max]}]")
           int_valid = CLI::Config.def_valid?(k, v) &&
             CLI::Config.int_valid?(unvalid)        &&
             unvalid.to_i >= v[:min]                &&
             unvalid.to_i <= v[:max]
-
-          Aro::V.say("validating #{k} (#{CLI::Config::DEF_TYPES[:INT][:name]})")
-          Aro::V.say("unvalid = #{unvalid}")
-          Aro::V.say("unvalid is#{int_valid ? " " : :" not ".to_s}valid.")
+          Aro::V.say("unvalid(#{unvalid}) is#{int_valid ? " " : :" not ".to_s}valid.")
           int_valid
         }
       },
       STRING: {
         name: :string,
-        description: I18n.t("cli.config.type_string_description"),
+        description: I18n.t("cli.config.type.string_description"),
+        converter: Proc.new{|v| v.to_s},
         validator: Proc.new{|unvalid, k, v|
-          unvalid.is_a?(String)
+          CLI::Config.def_valid?(k, v) &&
+          CLI::Config.string_valid?(unvalid)
         }
       },
       VALUES: {
         name: :values,
-        description: I18n.t("cli.config.type_values_description"),
+        description: I18n.t("cli.config.type.values_description"),
+        converter: Proc.new{|v| v.to_s},
         validator: Proc.new{|unvalid, k, v|
           CLI::Config.def_valid?(k, v) &&
           v[:possible_values].keys.include?(unvalid&.to_sym)
@@ -95,10 +130,18 @@ module CLI
       },
     }
 
+    def self.bool_valid?(unvalid)
+      CLI::Config::BOOLS.values.map{|b| b.to_s.to_sym}.include?(unvalid&.to_s&.to_sym)
+    end
+
     def self.int_valid?(unvalid)
       !unvalid&.to_i.nil?
     end
 
+    def self.string_valid?(unvalid)
+      unvalid.is_a?(String)
+    end
+
     def self.def_valid?(key, deff)
       def_valid = deff == CLI::Config::DEF[key]
       unless def_valid
@@ -109,80 +152,106 @@ module CLI
     end
 
     def validate_config
-      invalid_defs = []
-      CLI::Config::DEF.each{|k, v|        
-        invalid_defs << k unless validate_value(CLI::Config.ivar(k), k, v)
+      invalid_vars = []
+      CLI::Config::DEF.each{|k, v|
+        Aro::V.say(v[:access])
+        is_valid = v[:access] == CLI::Config::DEF_ACCESS[:READ]
+        unless is_valid
+          is_valid = valid_var?(CLI::Config.ivar(k), k, v)
+        end
+        invalid_vars << k unless is_valid
       }
-      invalid_defs
+      invalid_vars
     end
 
-    def validate_value(var_value, k, v)
+    def valid_var?(var_value, k, v)
+      Aro::V.say(v)
+      return true if v[:access] == CLI::Config::DEF_ACCESS[:READ]
+
       CLI::Config::DEF_TYPES[
         v[:type].to_s.upcase.to_sym
       ][:validator].call(var_value, k, v)
-    end   
+    end
+
+    def convert_var_for_def(k)
+      CLI::Config::DEF_TYPES[
+        CLI::Config::DEF[k][:type].upcase
+      ][:converter].call(ENV[CLI::Config.ivar_k(k)])
+    end
 
     # adapts I18n translations to generate bash environment vars.
     # 
     # example usage:
     # CLI::Config::DEF[:Z_MAX]
     DEF = {
-      # writable variables
+
+      #
+      # => ivars
+      #
       ENV: {
-        type: :values,
+        type: CLI::Config::TYPES[:VALUES],
         access: CLI::Config::DEF_ACCESS[:WRITE],
         value: CLI::Config::ENVS[:PRODUCTION],
-        description: I18n.t(
-          "cli.config.env_description",
-          possible_values: CLI::Config::ENVS.values.join(", ")
-         ),
+        description: I18n.t("cli.config.env.description"),
         possible_values: {
-          development: I18n.t("cli.config.env_development_description"),
-          production: I18n.t("cli.config.env_production_description"),
-          test: I18n.t("cli.config.env_test_description"),
+          development: I18n.t("cli.config.env.development_description"),
+          production: I18n.t("cli.config.env.production_description"),
+          test: I18n.t("cli.config.env.test_description"),
         }
       },
+      VERBOSE: {
+        type: CLI::Config::TYPES[:BOOL],
+        access: CLI::Config::DEF_ACCESS[:WRITE],
+        value: CLI::Config::BOOLS[:FALSE],
+        description: I18n.t("cli.config.verbose_description"),
+      },
       FORMAT: { # not implemented yet.
-        type: :values,
+        type: CLI::Config::TYPES[:VALUES],
         implemented: false,
         access: CLI::Config::DEF_ACCESS[:WRITE],
         value: CLI::Config::FORMATS[:TEXT],
-        description: I18n.t(
-          "cli.config.format_description",
-          possible_values: CLI::Config::FORMATS.values.join(", ")
-        ),
+        description: I18n.t("cli.config.format.description"),
         possible_values: {
-          text: I18n.t("cli.config.text_format_description"),
-          json: I18n.t("cli.config.json_format_description")
+          text: I18n.t("cli.config.format.text_description"),
+          json: I18n.t("cli.config.format.json_description")
         }
       },
       DIMENSION: {
-        type: :values,
+        type: CLI::Config::TYPES[:VALUES],
         access: CLI::Config::DEF_ACCESS[:WRITE],
         value: CLI::Config::DMS[:DEV_TAROT],
-        description: I18n.t(
-          "cli.config.dimension_description",
-          possible_values: CLI::Config::DMS.values.join(", ")
-         ),
+        description: I18n.t("cli.config.dimension.description"),
         possible_values: {
-          dev_tarot: I18n.t("cli.config.dimension_dev_tarot_description"),
-          ruby_facot: I18n.t("cli.config.dimension_ruby_facot_description"),
+          dev_tarot: I18n.t("cli.config.dimension.dev_tarot_description"),
+          ruby_facot: I18n.t("cli.config.dimension.ruby_facot_description"),
         }
       },
-      DISPLAY_COLUMNS: {
-        type: :int,
+      HEIGHT: {
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: Aro::Mancy::NUMERALS[:VII],
+        value: Aro::Mancy::NUMERALS[:XLII],
+        min: Aro::Mancy::NUMERALS[:I],
+        max: Aro::Mancy::NUMERALS[:MMXCVII],
+        description: I18n.t(
+          "cli.config.height_description",
+          min: Aro::Mancy::NUMERALS[:I],
+          max: Aro::Mancy::NUMERALS[:VII].pow(Aro::Mancy::OS),
+        ),
+      },
+      WIDTH: {
+        type: CLI::Config::TYPES[:INT],
+        access: CLI::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Mancy::NUMERALS[:C] + Aro::Mancy::NUMERALS[:XXXVII] - Aro::Mancy::S,
         min: Aro::Mancy::NUMERALS[:I],
-        max: Aro::Mancy::NUMERALS[:XXII] / Aro::Mancy::OS,
+        max: Aro::Mancy::NUMERALS[:MMXCVII],
         description: I18n.t(
-          "cli.config.display_columns_description",
+          "cli.config.width_description",
           min: Aro::Mancy::NUMERALS[:I],
-          max: Aro::Mancy::NUMERALS[:XXII] / Aro::Mancy::OS,
+          max: Aro::Mancy::NUMERALS[:XI].pow(Aro::Mancy::OS),
         ),
       },
       Z: {
-        type: :int,
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:WRITE],
         value: Aro::Mancy::NUMERALS[:I],
         min: Aro::Mancy::NUMERALS[:I],
@@ -194,7 +263,7 @@ module CLI
         ),
       },
       Z_MAX: {
-        type: :int,
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:WRITE],
         value: Aro::Mancy::NUMERALS[:VII],
         min: Aro::Mancy::NUMERALS[:I],
@@ -206,78 +275,81 @@ module CLI
         ),
       },
 
-      # read only variables
+      #
+      # => ovars
+      #
       ARO_ENV_O: {
-        type: :string,
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::O,
-        description: I18n.t(
-          "cli.config.aro_env_O_description"
-        ),
+        description: I18n.t("cli.config.aro_env.O_description"),
       },
       ARO_ENV_S: {
-        type: :string,
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::S,
-        description: I18n.t(
-          "cli.config.aro_env_S_description"
-        ),
+        description: I18n.t("cli.config.aro_env.S_description"),
       },
       ARO_ENV_OS: {
-        type: :string,
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::OS,
-        description: I18n.t(
-          "cli.config.aro_env_OS_description"
-        ),
+        description: I18n.t("cli.config.aro_env.OS_description"),
+      },
+      ARO_ENV_E: {
+        type: CLI::Config::TYPES[:INT],
+        access: CLI::Config::DEF_ACCESS[:READ],
+        value: Aro::Mancy::E,
+        description: I18n.t("cli.config.aro_env.E_description"),
       },
       ARO_ENV_N: {
-        type: :string,
+        type: CLI::Config::TYPES[:INT],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::N,
-        description: I18n.t(
-          "cli.config.aro_env_N_description"
-        ),
+        description: I18n.t("cli.config.aro_env.N_description"),
       },
       ARO_ENV_PS1: {
-        type: :string,
+        type: CLI::Config::TYPES[:STRING],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::PS1,
-        description: I18n.t(
-          "cli.config.aro_env_PS1_description"
-        ),
+        description: I18n.t("cli.config.aro_env.PS1_description"),
       },
       ARO_ENV_NAME_FILE: {
-        type: :string,
+        type: CLI::Config::TYPES[:STRING],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::NAME_FILE,
-        description: I18n.t(
-          "cli.config.aro_env_NAME_FILE_description"
-        ),
+        description: I18n.t("cli.config.aro_env.NAME_FILE_description"),
       },
       ARO_ENV_I2097I: {
-        type: :string,
+        type: CLI::Config::TYPES[:STRING],
         access: CLI::Config::DEF_ACCESS[:READ],
-        description: I18n.t(
-          "cli.config.aro_env_I2097I_description"
-        ),
-        value: Aro::Mancy::I2097I
+        value: Aro::Mancy::I2097I,
+        description: I18n.t("cli.config.aro_env.I2097I_description"),
       },
       ARO_ENV_YES: {
-        type: :string,
+        type: CLI::Config::TYPES[:STRING],
         access: CLI::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::YES,
-        description: I18n.t(
-          "cli.config.aro_env_YES_description"
-        ),
+        description: I18n.t("cli.config.aro_env.YES_description"),
+      },
+      ARO_ENV_ALL: {
+        type: CLI::Config::TYPES[:STRING],
+        access: CLI::Config::DEF_ACCESS[:READ],
+        value: Aro::Mancy::ALL,
+        description: I18n.t("cli.config.aro_env.ALL_description"),
       },
-
-      # ...
     }
 
     def initialize
-      Aro::P.say("config init")
-      return unless Aro::Mancy.is_aro_space? && Aro::Mancy.is_initialized?
+      @@context = nil
+      if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
+        @@context = Aro::Mancy.name
+      elsif Aro::Dom.in_arodom? && Aro::Dom.is_initialized?
+        @@context = Aro::Dom.name
+      end
+
+      return if @@context.nil?
+
       unless File.exist?(CLI::Config.config_filepath)
         generate_config
       end
@@ -287,33 +359,44 @@ module CLI
     end
 
     def self.config_filepath
-      File.join(Aro::Db.base_aro_dir, CLI::Config::CONFIG_FILE.to_s)
+      db_cls = @@context == Aro::Dom.name ? Aos::Db : Aro::Db
+      File.join(db_cls.base_aro_dir, CLI::Config::CONFIG_FILE.to_s)
     end
 
-    def self.display_config
-      Aro::V.say("getting display config...")
-      columns = CLI::Config.ivar(:DISPLAY_COLUMNS)
-      Aro::V.say("DISPLAY_COLUMNS: #{columns}")
-
-      # default
-      width = CLI::Config::DEF[:DISPLAY_COLUMNS][:value]
-      if columns.respond_to?(:to_i)
-        # user setting
-        columns = columns.to_i
-        width = columns.to_i.pow(Aro::Mancy::OS)
-      end
-      Aro::V.say("WIDTH: #{width}")
+    def self.is_test?
+      ENV[:ARO_ENV.to_s] == CLI::Config::ENVS[:TEST].to_s
+    end
 
-      {
+    def self.display_config
+      # Aro::V.say(__method__)
+      width = CLI::Config.ivar(:WIDTH).to_i
+      columns = width.pow(Aro::Mancy::S.to_f / Aro::Mancy::OS.to_f).to_i
+      result = {
         COLUMNS: columns,
+        HEIGHT: CLI::Config.ivar(:HEIGHT).to_i,
         WIDTH: width,
-        DIVIDER: :"-".to_s
+        DIVIDER: :"_".to_s
       }
+      # Aro::V.say(result)
+
+      result
+    end
+
+    def self.process_config_command(args)
+      if args[1].nil? || args[1] == :aos.to_s
+        # print config
+        Aro::P.say((
+          ["config loaded from #{CLI::Config.config_filepath}"] +
+          CLI::Config.dump_config
+        ).join("\n"))
+      elsif [args[2],args[3]].compact.any? && args[1] == Aos::Os::CMDS[:CONFIG][:cmds][:SET][:key].to_s
+        CLI::Config.set_ivar(args[2], args[3])
+      end
     end
 
     # out vars
     def self.ovar(suffix)
-      ENV[CLI::Config.ovar_k(suffix)]
+      CLI::Config::DEF[suffix][:value]
     end
     # out vars
     def self.ovar_k(suffix)
@@ -329,24 +412,57 @@ module CLI
       "#{CLI::Config::ARO_CONFIG_PREFIX}#{suffix}"
     end
 
+    def self.set_ivar(k, new_value)
+      k = k.upcase.to_sym
+
+      current_value = CLI::Config.ivar(k)
+      # ensure the var name is valid
+      unless current_value.nil?
+        Aro::V.say("validating #{k} with value #{new_value}")
+        if CLI::Config.instance.valid_var?(new_value, k, CLI::Config::DEF[k])
+          # set ENV value
+          ENV[CLI::Config.ivar_k(k)] = new_value
+          Aro::V.say(ENV[CLI::Config.ivar_k(k)])
+
+          # flush existing config and regen
+          CLI::Config.instance.generate_config(true)
+          CLI::Config.instance.source_config
+          CLI::Config.instance.setup_env
+        else
+          Aro::Dom::P.say("the ivar value you entered is invalid. ignoring.")
+        end
+      else
+        Aro::Dom::P.say("the ivar name you entered is invalid. ignoring.")
+      end
+    end
+
     def setup_env
       # do not change - update $ARO_CONFIG_ENV .aro/.config file
       # 
       # default is production
       varenv = CLI::Config.ivar(:ENV)
-      var_valid = validate_value(varenv, :ENV, CLI::Config::DEF[:ENV])
-      ENV[:ARO_ENV.to_s] = var_valid ? varenv : CLI::Config::ENVS[:PRODUCTION].to_s
+      is_valid = valid_var?(varenv, :ENV, CLI::Config::DEF[:ENV])
+      ENV[:ARO_ENV.to_s] = is_valid ? varenv : CLI::Config::ENVS[:PRODUCTION].to_s
       Aro::D.say("setup_env: #{ENV[:ARO_ENV.to_s]}")
     end
 
-    def self.is_test?
-      ENV[:ARO_ENV.to_s] == CLI::Config::ENVS[:TEST].to_s
+    def self.dump_config
+      dump = []
+      CLI::Config::DEF.each{|k, v|
+        if v[:access] == CLI::Config::DEF_ACCESS[:WRITE]
+          dump << "$#{CLI::Config.ivar_k(k).ljust(Aro::Mancy::NUMERALS[:XIV] * Aro::Mancy::OS)}=#{CLI::Config.ivar(k)}"
+        else
+          dump << "$#{CLI::Config.ovar_k(k).ljust(Aro::Mancy::NUMERALS[:XIV] * Aro::Mancy::OS)}=#{CLI::Config.ovar(k)}"
+        end
+      }
+
+      dump
     end
 
     def source_config
-      Aro::D.say(I18n.t("cli.config.sourcing_config", name: CLI::Config.config_filepath))
+      Aro::D.say(I18n.t("cli.config.source", name: CLI::Config.config_filepath))
       File.read(CLI::Config.config_filepath).split("\n").select{|line|
-        line.match?(/export #{:ARO_}/)
+        line.match?(/export #{CLI::Config::ARO_CONFIG_PREFIX}/)
       }.map{|line| 
         line.gsub("export ", "").split("=")
       }.each{|kv|
@@ -357,19 +473,20 @@ module CLI
       
       # todo: implement
       invalid_defs = validate_config
-      CLI::Config::DEF.keys.each{|dfk|
-        Aro::V.say("$#{CLI::Config.ivar_k(dfk)}=#{CLI::Config.ivar(dfk)}")
+      CLI::Config.dump_config.each{|l| Aro::V.say(l)}
+      invalid_defs.each{|k|
+        v = CLI::Config::DEF[k.to_sym]
+        if v[:access] == CLI::Config::DEF_ACCESS[:WRITE]
+          ENV[CLI::Config.ivar_k(k)] = v[:value]
+        else
+          ENV[CLI::Config.ovar_k(k)] = v[:value]
+        end
       }
-      Aro::V.say("todo: invalid_defs: #{invalid_defs}")
-      # todo: set all invalid_refs to default in ENV
-      # invalid_defs.each{|id| 
-
-      # }
     end
 
-    def generate_config
+    def generate_config(from_memory = false)
       # todo: localize generated config text
-      Aro::D.say(I18n.t("cli.config.generating_default_config", name: CLI::Config.config_filepath))
+      Aro::D.say(I18n.t("cli.config.generate", name: CLI::Config.config_filepath))
       File.open(CLI::Config.config_filepath, "w+") do |file|
         # intro
         Aro::Mancy::OS.times do
@@ -404,7 +521,7 @@ module CLI
 
         # vars
         CLI::Config::DEF.each{|k, v|
-          print_var file.object_id, k, v
+          print_var file.object_id, k, v, (from_memory ? ENV[CLI::Config.ivar_k(k)] : nil)
         }
 
         print_osr file.object_id
@@ -475,7 +592,7 @@ module CLI
       file.write("#     => which can be used to write programs on top of aro.\n")
     end
 
-    def print_var f_object_id, k, v
+    def print_var f_object_id, k, v, mem_v
       file = ObjectSpace._id2ref f_object_id
 
       is_ovar = CLI::Config::DEF[k][:access] == CLI::Config::DEF_ACCESS[:READ]
@@ -487,17 +604,17 @@ module CLI
       Aro::V.say("access for #{k} is #{CLI::Config::DEF[k][:access]}")
       Aro::V.say("using var_name: #{var_name}")
       file.write("# [#{var_name}] (#{is_ovar ? :ovar : :ivar})\n")
-      file.write("#   => #{I18n.t("cli.config.def_type")}: #{v[:type]}\n")
+      file.write("#   => CLI::Config::DEF_TYPES: #{v[:type]}\n")
       case v[:type]
       when CLI::Config::DEF_TYPES[:INT][:name]
-        file.write("#   => #{I18n.t("cli.config.type_int_description")}\n")
+        file.write("#   => #{I18n.t("cli.config.type.int_description")}\n")
         file.write("#   => #{I18n.t("cli.config.minimum")}: #{v[:min]}\n")
         file.write("#   => #{I18n.t("cli.config.maximum")}: #{v[:max]}\n")
       when CLI::Config::DEF_TYPES[:STRING][:name]
-        file.write("#   => #{I18n.t("cli.config.type_string_description")}\n")
+        file.write("#   => #{I18n.t("cli.config.type.string_description")}\n")
         file.write("#   => use \"double quotes\" if there are any spaces.\n")
       when CLI::Config::DEF_TYPES[:VALUES][:name]
-        file.write("#   => #{I18n.t("cli.config.type_values_description")}\n")
+        file.write("#   => #{I18n.t("cli.config.type.values_description")}\n")
         file.write("#   => #{I18n.t("cli.config.possible_values")}:\n")
         print_sr f_object_id
         v[:possible_values].each{|name, description|
@@ -510,7 +627,11 @@ module CLI
       print_osr f_object_id
       file.write("#   => description:\n")
       file.write("#   => #{v[:description]}\n")
-      file.write("export #{var_name}=#{v[:value]}\n")
+      if is_ovar && CLI::Config::DEF_TYPES[:STRING][:name] == v[:type]
+        file.write("export #{var_name}=\"#{v[:value]}\"\n")
+      else
+        file.write("export #{var_name}=#{mem_v || v[:value]}\n")
+      end
       print_osr f_object_id
     end
 

data/sys/cli/constants.rb

@@ -18,12 +18,16 @@ module CLI
   }
 
   EXIT_CODES = {
-    SUCCESS: 0,
-    GENERAL_ERROR: 1,
-    INVALID_ARG: 3
+    SUCCESS: Aro::Mancy::O,
+    GENERAL_ERROR: Aro::Mancy::S,
+    INVALID_ARG: Aro::Mancy::E,
   }
 
   CMDS = {
+    AOS: {
+      RUN: :run,
+      WATCH: :watch,
+    },
     ARO: {
       CREATE: :create,
       CONFIG: :config,
@@ -45,9 +49,8 @@ module CLI
     },
     DOM: {
       INIT: :init,
-      MAP: :map,
       NEW: :new,
-    }
+    },
   }
   
 end

data/sys/cli/deck.rb

@@ -13,11 +13,11 @@ module CLI
   def self.deck
     action = CLI::ARGV1&.to_sym
 
-    if CLI::FLAGS[:HELP].include?(CLI::ARGV1)
+    if CLI::FLAGS[:HELP].include?(action.to_s)
       # todo: breakout usage into subcommand-specific verbiage
       CLI.usage::usage
       exit(CLI::EXIT_CODES[:SUCCESS])
-    elsif CLI::ARGV1.nil?
+    elsif action.nil? || action == :aos
       # no args, open deck menu
       Aro::Db.new
       Aro::Deck.display_selection_menu
@@ -51,7 +51,7 @@ module CLI
         Aro::P.say(I18n.t("cli.messages.replacing_drawn", name: Aro::Mancy.game.name))
         Aro::Mancy.game.replace
       when CLI::CMDS[:DECK][:RESET]
-        if Aro::Mancy::YES.to_s != Aro::P.p.ask(I18n.t("cli.messages.confirmation_prompt", name: Aro::Mancy.game.name))
+        if Aro::Mancy::YES.to_s != Aro::P.p.ask("#{Aro::Mancy::PS1}#{I18n.t("cli.messages.confirmation_prompt", name: Aro::Mancy.game.name)}")
           Aro::P.say(I18n.t("cli.messages.understood", name: Aro::Mancy.game.name))
           exit(CLI::EXIT_CODES[:SUCCESS])
         end
@@ -60,6 +60,11 @@ module CLI
         Aro::Mancy.game.reset
       end
 
+      if ARGV.include?(:aos.to_s)
+        # run silent
+        exit(CLI::EXIT_CODES[:SUCCESS])
+      end
+
       Aro::Mancy.game.show(**CLI::shoptions)
     end
   end
@@ -70,23 +75,23 @@ module CLI
     show_options_count = Aro::Mancy::S
     show_options_order = Aro::Log::ORDERING[:DESC]
     
-    # Aro::P.say("ARGV.map{|a| a.to_sym} => #{ARGV.map{|a| a.to_sym}}")
+    # Aro::D.say("ARGV.map{|a| a.to_sym} => #{ARGV.map{|a| a.to_sym}}")
     
     count_option_flags = ARGV.map{|a| a.to_sym} & CLI::FLAGS[:SHOW_COUNT]
-    # Aro::P.say("count_option_flags: #{count_option_flags}")
+    # Aro::D.say("count_option_flags: #{count_option_flags}")
     if count_option_flags.any?
       # get the ARGV index element after flag index
       show_options_count = ARGV[ARGV.index(count_option_flags.first.to_s) + 1]
       show_options_count = show_options_count.to_i unless [0, nil].include?(show_options_count&.to_i)
-      # Aro::P.say("show_options_count: #{show_options_count}")
+      # Aro::D.say("show_options_count: #{show_options_count}")
     end
 
     order_option_flags = ARGV.map{|a| a.to_sym} & CLI::FLAGS[:SHOW_ORDER]
-    # Aro::P.say("count_option_flags: #{order_option_flags}")
+    # Aro::D.say("count_option_flags: #{order_option_flags}")
     if order_option_flags.any?
       # get the ARGV index element after flag index
       show_options_order = ARGV[ARGV.index(order_option_flags.first.to_s) + 1].to_sym
-      Aro::P.say("show_options_order: #{show_options_order}")
+      # Aro::D.say("show_options_order: #{show_options_order}")
     end
 
     {