woods 1.6.1 → 2.0.0.beta2

data/lib/woods/mcp/config_resolver.rb

@@ -61,6 +61,11 @@ module Woods
       #   in the deprecated auto-detect path. Defaults to {.ollama_reachable?} on
       #   this module. Callers may pass a different probe to facilitate testing
       #   without touching global state.
+      # @param stored_config [Woods::ResolvedConfig, nil] a pre-captured stored
+      #   config to reconcile against INSTEAD of re-reading +artifact+ (M7: the
+      #   reload transaction captures the config from the dump identity it
+      #   pinned, so a concurrent promotion cannot change it mid-build). Nil
+      #   keeps the default behavior of reading the artifact.
       # @return [Array(Woods::Configuration, Symbol)] tuple of +[config, source]+
       #   where +source+ is one of +:snapshot+, +:host_config+, +:autodetect+,
       #   or +:none+. The config is the same object passed in, possibly mutated.
@@ -72,8 +77,8 @@ module Woods
       #   dimensions disagree.
       # @raise [Woods::MCP::ConfigMismatch] when stored and live provider
       #   class/model disagree.
-      def self.resolve(config, artifact:, env: ENV, ollama_probe: nil)
-        stored = read_stored_config(artifact)
+      def self.resolve(config, artifact:, env: ENV, ollama_probe: nil, stored_config: :not_given)
+        stored = stored_config == :not_given ? read_stored_config(artifact) : stored_config
 
         if stored
           [apply_stored_config(config, stored, artifact: artifact, env: env), :snapshot]
@@ -86,14 +91,22 @@ module Woods
         end
       end
 
-      # Read and parse +woods.json+ if it exists.
+      # Read and parse the resolved config snapshot, if one exists.
+      #
+      # Delegates entirely to {IndexArtifact#read_config}, which prefers the
+      # config embedded in the promoted dump over the root +woods.json+ (#217
+      # / FIX 3 — the two used to be independent atomic writes, so a crash
+      # between them could publish a new config against the old dump). Do
+      # NOT gate on +artifact.config_path.exist?+ here: a promoted dump can
+      # carry its own config with no root +woods.json+ ever having been
+      # written, and that pre-check would skip straight past it.
       #
       # @param artifact [Woods::IndexArtifact, nil]
       # @return [Woods::ResolvedConfig, nil]
       # @raise [Woods::MCP::UnsupportedArtifact] if the file has an unsupported
       #   schema version.
       def self.read_stored_config(artifact)
-        return nil unless artifact&.config_path&.exist?
+        return nil unless artifact
 
         raw = artifact.read_config
         return nil unless raw
@@ -142,7 +155,8 @@ module Woods
       # Populate a blank {Woods::Configuration} from a stored {ResolvedConfig}.
       #
       # Maps the serialised provider class name back to the +:ollama+ /
-      # +:openai+ symbol that {Builder} expects, and restores store types.
+      # +:openai+ / +:fake+ symbol that {Builder} expects, and restores
+      # store types.
       # Applied when an MCP server starts without a host Rails initializer.
       #
       # @param config [Woods::Configuration]
@@ -150,9 +164,11 @@ module Woods
       # @param artifact [Woods::IndexArtifact]
       # @return [Woods::Configuration]
       def self.populate_from_stored(config, stored, artifact:, env: ENV)
+        config.output_dir = artifact.output_dir.to_s
         config.vector_store = stored.stores[:vector_store] || :in_memory
         config.metadata_store = stored.stores[:metadata_store] || :in_memory
         config.graph_store = stored.stores[:graph_store] || :in_memory
+        restore_store_options(config, stored, artifact: artifact, env: env)
         provider_sym = provider_symbol(stored.embedding_provider[:class])
         config.embedding_provider = provider_sym
 
@@ -170,8 +186,10 @@ module Woods
         # ArgumentError from OpenAI.new(**opts) wasn't a BootstrapError
         # and the top-level rescue in exe/woods-mcp wouldn't catch it.
         if provider_sym == :openai
+          # Strip-aware, matching the resolver-default path (:321): a
+          # whitespace-only key is not a credential on either path (R1-5).
           api_key = env.fetch('OPENAI_API_KEY', nil)
-          if api_key.nil? || api_key.empty?
+          if api_key.nil? || api_key.strip.empty?
             raise Woods::MCP::MissingCredential.new(
               'woods.json says the index was embedded with OpenAI but OPENAI_API_KEY is unset. ' \
               'Export the key before starting the MCP server, or re-embed with a different provider.',
@@ -189,6 +207,43 @@ module Woods
       end
       private_class_method :populate_from_stored
 
+      def self.restore_store_options(config, stored, artifact:, env:)
+        if config.metadata_store == :sqlite
+          config.metadata_store_options = { database: artifact.output_dir.join('metadata.sqlite3').to_s }
+        end
+
+        options = stored.store_options.fetch(:vector_store, {}).dup
+        case config.vector_store
+        when :qdrant
+          options.delete(:url)
+          options[:url] = env['WOODS_QDRANT_URL'] unless env['WOODS_QDRANT_URL'].to_s.empty?
+          if options[:collection].to_s.empty? && !env['WOODS_QDRANT_COLLECTION'].to_s.empty?
+            options[:collection] = env['WOODS_QDRANT_COLLECTION']
+          end
+          options[:api_key] = env['WOODS_QDRANT_API_KEY'] unless env['WOODS_QDRANT_API_KEY'].to_s.empty?
+          require_store_setting!(options, :url, 'WOODS_QDRANT_URL', :qdrant)
+          require_store_setting!(options, :collection, 'WOODS_QDRANT_COLLECTION', :qdrant)
+        when :pgvector
+          url = env['WOODS_PG_URL']
+          if url.to_s.empty?
+            raise ConfigMismatch, 'pgvector index requires WOODS_PG_URL when served outside its host application.'
+          end
+
+          require 'active_record'
+          options[:connection] = ActiveRecord::Base.establish_connection(url).connection
+        end
+        config.vector_store_options = options unless options.empty?
+      end
+      private_class_method :restore_store_options
+
+      def self.require_store_setting!(options, key, env_name, adapter)
+        return unless options[key].to_s.empty?
+
+        raise ConfigMismatch,
+              "#{adapter} index is missing #{key}; set #{env_name} or re-embed so woods.json records it."
+      end
+      private_class_method :require_store_setting!
+
       # Convert a fully-qualified provider class name back to the symbol
       # that {Builder} understands.
       #
@@ -198,6 +253,7 @@ module Woods
         case class_name.to_s
         when /Ollama/ then :ollama
         when /OpenAI/ then :openai
+        when /Fake/ then :fake
         else class_name.to_s
         end
       end
@@ -261,6 +317,10 @@ module Woods
       def self.autodetect_from_env(config, env:, ollama_probe:)
         probe = ollama_probe || method(:ollama_reachable?)
         openai_key = env.fetch('OPENAI_API_KEY', nil)
+        # A blank key is an absent key (M9). Truthiness alone wired :openai
+        # with api_key: "" — skipping the Ollama probe a missing key gets —
+        # and then died at Builder time with a raw ConfigurationError.
+        openai_key = nil if openai_key.is_a?(String) && openai_key.strip.empty?
         if openai_key
           config.vector_store = :in_memory
           config.metadata_store = :in_memory

data/lib/woods/mcp/errors.rb

@@ -132,5 +132,65 @@ module Woods
         'provider unreachable'
       end
     end
+
+    # Raised when an MCP +reload+ transaction cannot complete (M7). Deliberately
+    # a sibling of {BootstrapError}, not a child: this describes a runtime
+    # reload attempt, not boot state. The transaction is all-or-nothing —
+    # when this is raised, the reader caches and the retriever's store bundle
+    # were NOT touched and the previous generation is still being served.
+    #
+    # The exception carries the payload of the reload-phase degraded condition:
+    # the generation still being served, and the store component(s) whose
+    # refresh failed. The +reload+ tool maps it to a +degraded_index+ tool
+    # error with +phase: 'reload'+, and {BootstrapState#record_reload_failure}
+    # persists the same shape for +woods_status+.
+    #
+    # @example Raising from the reload transaction
+    #   raise Woods::MCP::ReloadDegraded.new(
+    #     "vector hydration failed: IOError: dump vanished",
+    #     generation: served_marker.number, stores: [:vector], error: e
+    #   )
+    class ReloadDegraded < Woods::Error
+      # @return [Integer] the generation number still being served
+      attr_reader :generation
+
+      # @return [Array<String>] store component(s) whose refresh failed
+      #   (subset of +vector+, +metadata+, +graph+; all three when the
+      #   failure is not attributable to one component)
+      attr_reader :stores
+
+      # @return [Exception, nil] the underlying error, when the failure was
+      #   caused by one
+      attr_reader :cause_error
+
+      # @param message [String]
+      # @param generation [Integer] generation still being served
+      # @param stores [Array<Symbol, String>] failing store component(s)
+      # @param error [Exception, nil] underlying cause
+      def initialize(message, generation:, stores:, error: nil)
+        super(message)
+        @generation = generation
+        @stores = Array(stores).map(&:to_s)
+        @cause_error = error
+      end
+    end
+
+    # The generation recheck inside a reload transaction failed: the on-disk
+    # generation moved while candidate stores were being built off-side, so
+    # the built bundle is stale. Swapping it would pair reader state from one
+    # generation with stores from another. Nothing is swapped; the next
+    # +reload+ invocation is the recovery path (it rebuilds candidates
+    # against the fresh generation).
+    class ReloadGenerationMoved < ReloadDegraded; end
+
+    # The promoted-dump recheck inside a reload transaction failed. The embed
+    # path's commit point ({IndexArtifact#promote}, which flips +dumps/latest+)
+    # does not bump the generation file, so an embed-only publication moves
+    # the dump identity WITHOUT moving the generation marker — this recheck is
+    # the only thing standing between a reload and a bundle whose vector and
+    # metadata halves were hydrated from two different dumps. Nothing is
+    # swapped; the next +reload+ re-captures and rebuilds against whatever is
+    # promoted by then.
+    class ReloadDumpMoved < ReloadDegraded; end
   end
 end