samagotchi 0.4.0 → 0.5.0

data/lib/samagotchi/config.rb

@@ -83,7 +83,7 @@ module Samagotchi
 
       Entry.new(key: "session.retention_days",        yaml_path: %w[session retention_days],        type: :integer, default: 14,   expose: %i[env config cli]),
       Entry.new(key: "session.max_count",             yaml_path: %w[session max_count],             type: :integer, default: 500,  expose: %i[env config cli]),
-      Entry.new(key: "session.keep_status",           yaml_path: %w[session keep_status],           type: :string, default: "running", expose: %i[env config cli]),
+      Entry.new(key: "session.keep_status",           yaml_path: %w[session keep_status],           type: :string, default: "", expose: %i[env config cli]),
       Entry.new(key: "session.sweep_interval_hours",  yaml_path: %w[session sweep_interval_hours],  type: :integer, default: 24,   expose: %i[env config cli]),
       Entry.new(key: "session.idle_exit_minutes",     yaml_path: %w[session idle_exit_minutes],     type: :float,   default: 30.0, expose: %i[env config cli]),
       # Plain `chi` runs like `chi --shared` (bin/chi, LaunchMode); false, or --no-shared per run, keeps the plain REPL. No CLI flag: that would duplicate --shared.
@@ -108,9 +108,6 @@ module Samagotchi
       Entry.new(key: "log.level",                yaml_path: %w[log level],                type: :enum,   default: "info",           expose: %i[env config cli], enum_values: %w[debug info warn error]),
 
       Entry.new(key: "status.line",              yaml_path: %w[status line],              type: :string, default: "on",             expose: %i[env config cli]),
-      Entry.new(key: "status.width_mode",        yaml_path: %w[status width_mode],        type: :string, default: "terminal_cap",   expose: %i[env config cli]),
-      Entry.new(key: "status.max_width",         yaml_path: %w[status max_width],         type: :integer, default: 160,             expose: %i[env config cli]),
-      Entry.new(key: "status.fixed_width",       yaml_path: %w[status fixed_width],       type: :integer, default: 120,             expose: %i[env config cli]),
 
       Entry.new(key: "context.status",           yaml_path: %w[context status],           type: :bool,   default: true,             expose: %i[env config cli]),
       Entry.new(key: "context.window_tokens",    yaml_path: %w[context window_tokens],    type: :integer, default: nil,             expose: %i[env config cli]),
@@ -118,8 +115,6 @@ module Samagotchi
       Entry.new(key: "context.status_thresholds", yaml_path: %w[context status_thresholds],type: :string, default: "20,40,60,80",    expose: %i[env config cli]),
       Entry.new(key: "context.status_cadence",   yaml_path: %w[context status_cadence],   type: :integer, default: 0,               expose: %i[env config cli]),
 
-      Entry.new(key: "thinking.ui",              yaml_path: %w[thinking ui],              type: :string, default: nil,              expose: %i[env config cli]),
-      Entry.new(key: "thinking.render_interval", yaml_path: %w[thinking render_interval], type: :float,   default: 0.08,            expose: %i[env config cli]),
       Entry.new(key: "thinking.turn_preamble",   yaml_path: %w[thinking turn_preamble],   type: :bool,   default: true,             expose: %i[env config cli]),
       # How much models think: off|low|medium|high|default, parsed by Thinking
       # (a :string, since YAML reads an unquoted off as false). The CLI flag
@@ -153,8 +148,8 @@ module Samagotchi
       Entry.new(key: "web.port",                 yaml_path: %w[web port],                 type: :integer, default: 4567,            expose: %i[env config cli]),
       Entry.new(key: "web.host",                 yaml_path: %w[web host],                 type: :string, default: "127.0.0.1",     expose: %i[env config cli]),
       Entry.new(key: "web.markdown",             yaml_path: %w[web markdown],             type: :bool,    default: false,           expose: %i[env config cli]),
-      # The page shows each turn as one block of generations (the live one at the bottom); false brings back the row of bubbles; ?view=turn|chat overrides it per page load.
-      Entry.new(key: "web.turn_view",            yaml_path: %w[web turn_view],            type: :bool,    default: true,           expose: %i[env config cli]),
+      # The page's view of a turn: turn (one block of generations, the live one at the bottom), stage (the running turn pinned above the composer) or chat (a row of bubbles); ?view= overrides it per page load.
+      Entry.new(key: "web.view",                 yaml_path: %w[web view],                 type: :enum,    default: "turn",         expose: %i[env config cli], enum_values: %w[turn stage chat]),
       # Quick replies next to Annotate in the page's selection bubble, "|"-separated (a YAML list works too); "" leaves only Annotate.
       Entry.new(key: "web.annotate_presets",     yaml_path: %w[web annotate_presets],     type: :string, default: "Agreed|Could you please elaborate?", expose: %i[env config cli]),
 
@@ -179,12 +174,9 @@ module Samagotchi
     }.freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
-    # Removed settings that warn on their own (Engine.warn_removed_backend_setting).
-    REMOVED_KEYS = %w[backend].freeze
 
     # Fast lookup maps
     BY_KEY = ENTRIES.each_with_object({}) { |e, h| h[e.key] = e }.freeze
-    BY_ENV = ENTRIES.each_with_object({}) { |e, h| h[e.env_key] = e }.freeze
 
     class << self
       # The +candidates+ within edit distance 2 of +probe+, closest first
@@ -197,10 +189,6 @@ module Samagotchi
         BY_KEY[key.to_s]
       end
 
-      def find_by_env(env_key)
-        BY_ENV[env_key.to_s]
-      end
-
       def all_entries
         ENTRIES
       end
@@ -316,26 +304,10 @@ module Samagotchi
       end
 
       # Lookup yaml_path in nested hash, accepting snake leaf, kebab alias and
-      # entry-specific yaml_aliases, then legacy flat UPPER keys (e.g.,
-      # SAMAGOTCHI_DEFAULT_MODEL) for transition: the nested key wins when a
-      # file has both (ConfigFile.load_global_env! warns about that).
+      # entry-specific yaml_aliases.
       def lookup_yaml(data, yaml_path)
         entry = ENTRIES.find { |e| e.yaml_path == yaml_path }
-        nested = lookup_nested(data, yaml_path, entry)
-        return nested unless nested.nil?
-
-        lookup_legacy(data, entry)
-      end
-
-      # The legacy flat key's value for +entry+, or nil.
-      def lookup_legacy(data, entry)
-        return nil unless entry && data.is_a?(Hash)
-
-        key = entry.env_key
-        return data[key] if data.key?(key)
-        return data[key.to_sym] if data.key?(key.to_sym)
-
-        nil
+        lookup_nested(data, yaml_path, entry)
       end
 
       # The nested key's value for +yaml_path+, or nil.
@@ -374,21 +346,11 @@ module Samagotchi
         end
       end
 
-      # Convenience: load file_data from path + snapshot
-      def load_snapshot(path: nil, env: ENV, cli_overrides: {})
-        path ||= Samagotchi::ConfigFile.global_path(env: env) rescue nil
-        file_data = Samagotchi::ConfigFile.read_yaml(env: env, path: path) if path
-        snapshot(file_data: file_data, env: env, cli_overrides: cli_overrides)
-      end
-
-      # In-memory store for current process (populated after CLI parse)
-      def store
-        @store ||= load_snapshot
-      end
-
-      def reload!(path: nil, env: ENV, cli_overrides: {})
+      # Set this process's CLI settings (bin/chi, after it parsed the flags).
+      # Nothing is cached: #get resolves every call, reading config.yml
+      # again when it changed.
+      def reload!(cli_overrides: {})
         @cli_overrides = cli_overrides.dup
-        @store = load_snapshot(path: path, env: env, cli_overrides: cli_overrides)
       ensure
         # The log resolves its file and level from here.
         Samagotchi::Log.invalidate! if defined?(Samagotchi::Log)
@@ -398,6 +360,18 @@ module Samagotchi
         @cli_overrides ||= {}
       end
 
+      # This process's CLI settings as the env a spawned worker takes them
+      # from ({"SAMAGOTCHI_..." => "value"}): a worker gets no CLI args, and
+      # reads everything else from ENV and config.yml itself.
+      def cli_env
+        cli_overrides.each_with_object({}) do |(key, value), env|
+          entry = find_by_key(key) || ENTRIES.find { |e| e.cli_flag == key.to_s }
+          next unless entry&.env_exposed? && !value.nil?
+
+          env[entry.env_key] = value.to_s
+        end
+      end
+
       def get(key)
         get_with_origin(key).first
       end
@@ -433,13 +407,13 @@ module Samagotchi
       # code doesn't read (with a "did you mean" when a known key is close).
       # Every config-exposed entry in ENTRIES is known as written; names under
       # the maps are the user's, and host/model entries may hold the keys
-      # their readers take. Legacy flat keys warn in ConfigFile.load_global_env!.
+      # their readers take.
       def validate_yaml_sections(data)
         return [] unless data.is_a?(Hash)
 
         data.flat_map do |key, value|
           key = key.to_s
-          if find_by_env(key)&.config_exposed? || FREE_FORM_MAPS.include?(key) || REMOVED_KEYS.include?(key)
+          if FREE_FORM_MAPS.include?(key)
             []
           elsif MAP_ENTRY_KEYS.key?(key)
             map_entry_problems(key, value)
@@ -474,7 +448,7 @@ module Samagotchi
       def key_problem(dotted)
         return nil if known_config_keys.include?(dotted)
 
-        entry = find_by_key(dotted) || find_by_env(dotted)
+        entry = find_by_key(dotted)
         if entry
           where = entry.cli_exposed? ? "#{entry.env_key} or #{entry.cli_flag}" : entry.env_key
           return "config: '#{dotted}' can't be set in config.yml; use #{where}"
@@ -482,7 +456,7 @@ module Samagotchi
 
         canonical = ENTRIES.select(&:config_exposed?).map(&:key) + known_sections.to_a +
                     SECTION_EXTRA_KEYS.flat_map { |s, leaves| leaves.map { |l| "#{s}.#{l}" } } + FREE_FORM_MAPS + MAP_ENTRY_KEYS.keys
-        # A legacy-looking flat key compares by its nested form.
+        # A flat SAMAGOTCHI_* key (the env name) compares by its nested form.
         probe = dotted.start_with?("SAMAGOTCHI_") ? dotted.delete_prefix("SAMAGOTCHI_").downcase : dotted
         unknown_key_message(dotted, probe, canonical)
       end
@@ -533,7 +507,6 @@ module Samagotchi
     XDG_CONFIG_HOME_ENV = "XDG_CONFIG_HOME"
     CONFIG_DIR = "samagotchi"
     CONFIG_FILE = "config.yml"
-    DEFAULT_MODEL_KEY = "SAMAGOTCHI_DEFAULT_MODEL"
     MODEL_ALIASES_KEY = "model_aliases"
     MODELS_KEY = "models"
 
@@ -641,47 +614,18 @@ module Samagotchi
       end
     end
 
-    # New unified loader: delegates to Samagotchi::Config registry.
-    # Breaking: YAML now expects lower snake dotted paths (default.model)
-    # instead of UPPER scalar keys. For compatibility, UPPER keys are warned
-    # and ignored — env wins over file as before, now via registry precedence
-    # (CLI > ENV > file > default). Returns true if file existed.
-    def load_global_env!(env: ENV, path: global_path(env: env))
+    # Check config.yml once at start (warnings for keys the code doesn't
+    # read) and clear the CLI settings. Nothing is copied into ENV: every
+    # Config.get reads the file again when it changed, so a long-lived
+    # process (chi web) and the workers it spawns see edits, and a file
+    # value reports origin :file. Returns true if the file existed.
+    def load!(env: ENV, path: global_path(env: env))
       existed = File.file?(path)
       raw = read_yaml(env: env, path: path) || {}
       if existed
         Samagotchi::Config.validate_yaml_sections(raw).each { |w| Log.warn(:config, "config_key", echo: "Warning: #{w}") }
-        # Warn on legacy UPPER keys; the nested key wins when both are set.
-        # Any other flat key is unknown to validate_yaml_sections.
-        raw.each_key do |k|
-          entry = Samagotchi::Config.find_by_env(k)
-          next unless entry&.config_exposed?
-
-          if !Samagotchi::Config.lookup_nested(raw, entry.yaml_path, entry).nil?
-            nested = entry.yaml_path.join(".")
-            Log.warn(:config, "legacy_key", echo: "Warning: config: both '#{k}' and '#{nested}' are set; using '#{nested}', remove the flat key", key: k.to_s)
-          else
-            Log.warn(:config, "legacy_key", echo: "Warning: config key '#{k}' is legacy UPPER — use '#{entry.yaml_path.join('.')}'", key: k.to_s)
-          end
-        end
-      end
-      # For process-wide access, prime the Config store (so Config.get works)
-      Samagotchi::Config.reload!(path: path, env: env, cli_overrides: {})
-      # Keep ENV in sync for any code still reading ENV directly (transition).
-      # Only for keys that were actually present in file (not defaults) to
-      # avoid polluting ENV with defaults.
-      Samagotchi::Config.all_entries.each do |entry|
-        next unless entry.env_exposed?
-        # The env's thinking.level outranks models:/hosts: levels, the file's doesn't (Thinking.resolve).
-        next if entry.key == "thinking.level"
-        # check if file actually contained this key (including legacy flat)
-        file_val = Samagotchi::Config.lookup_yaml(raw, entry.yaml_path)
-        file_val ||= raw[entry.env_key] if raw.key?(entry.env_key)
-        next if file_val.nil?
-        val = Samagotchi::Config.store[entry.key]
-        next if val.nil?
-        env[entry.env_key] = val.to_s unless env.key?(entry.env_key)
       end
+      Samagotchi::Config.reload!(cli_overrides: {})
       existed
     end
 
@@ -815,15 +759,16 @@ module Samagotchi
         end
       end
 
-      # If no hosts defined, synthesize "default" from SAMAGOTCHI_SERVER_HOST/PORT
+      # If no hosts defined, synthesize "default" from server.host/port/transport.
       if normalized.empty?
-        default_host = env.fetch("SAMAGOTCHI_SERVER_HOST", "localhost").to_s.strip
+        opts = { file_data: data, env: env, cli_overrides: Samagotchi::Config.cli_overrides }
+        default_host = Samagotchi::Config.resolve("server.host", **opts).to_s.strip
         default_host = "localhost" if default_host.empty?
-        default_port = env.fetch("SAMAGOTCHI_SERVER_PORT", "8080").to_s.strip
-        default_port = default_port.empty? ? 8080 : default_port.to_i
+        default_port = Samagotchi::Config.resolve("server.port", **opts).to_i
         default_port = 8080 if default_port <= 0 || default_port > 65535
-        transport_env = env.fetch("SAMAGOTCHI_SERVER_TRANSPORT", "").to_s.strip.downcase
-        transport_sym = VALID_TRANSPORTS_FOR_CONFIG.include?(transport_env) ? transport_env.to_sym : nil
+        transport_sym = Samagotchi::Config.resolve_with_origin("server.transport", **opts).then do |value, origin|
+          origin == :default ? nil : value.to_sym
+        end
         normalized["default"] = { name: "default", host: default_host, port: default_port, transport: transport_sym, original_name: "default" }
       end
       normalized
@@ -959,23 +904,18 @@ module Samagotchi
 
       raw_data = read_yaml(env: env, path: path) || {}
 
-      # Migrate to new dotted nested form: default.model (Option A)
       raw_data["default"] ||= {}
       if raw_data["default"].is_a?(Hash)
         raw_data["default"]["model"] = resolved
       else
         raw_data["default"] = { "model" => resolved }
       end
-      # Remove legacy UPPER key if present
-      raw_data.delete(DEFAULT_MODEL_KEY)
       FileUtils.mkdir_p(File.dirname(path))
       tmp = "#{path}.tmp"
       File.write(tmp, YAML.dump(raw_data))
       File.rename(tmp, path)
       clear_yaml_cache!(path)
-      env[DEFAULT_MODEL_KEY] = resolved
-      # Also sync new Config store if loaded
-      Samagotchi::Config.reload!(path: path, env: env, cli_overrides: {})
+      Samagotchi::Config.reload!(cli_overrides: Samagotchi::Config.cli_overrides)
       true
     end