woods 1.6.0 → 2.0.0.beta1

data/lib/woods/checks/moved_messages.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Woods
+  module Checks
+    # Public methods that look like they moved from one unit to another
+    # between two generations while their test coverage did not follow
+    # (#280, 2026-09-09 ruling).
+    #
+    # A refactor that pulls `total` out of `Checkout` into `Pricing` keeps
+    # `spec/checkout_spec.rb` green only until the old call site goes; if
+    # nothing covers `Pricing`, the moved message is now untested. The check
+    # is a set difference over method lists in two {Woods::PublishedIndex}
+    # generations, joined with `:test_coverage` edges from the same
+    # generations.
+    #
+    # Each row is a **candidate** move into a unit without mapped tests, not
+    # a proven coverage loss: matching is by name and kind alone, so two
+    # unrelated methods that happen to share both are indistinguishable from
+    # a real move. This is a heuristic by design (see `docs/PUBLISHED_INDEX.md`
+    # and the rake task's `desc`), and is reported only when the source unit
+    # was covered before and the destination unit is not covered after; a
+    # method that was never covered is not a regression this check owns.
+    #
+    # Consumes anything shaped like {Woods::PublishedIndex}: `#units`,
+    # `#unit(identifier)`, and `#edges(via:)`. It never opens an index
+    # itself, so it needs no Rails and takes no retention lock of its own.
+    #
+    # @example
+    #   before = Woods::PublishedIndex.new(dir, generation: 41)
+    #   after  = Woods::PublishedIndex.new(dir, generation: 42)
+    #   Woods::Checks::MovedMessages.new(before: before, after: after).run
+    #   # => [#<Finding method="total" kind=:instance from_unit="Checkout" ...>]
+    #
+    class MovedMessages
+      # Metadata keys extractors use for method lists (see
+      # `docs/PUBLISHED_INDEX.md`'s "Moved-message check" section for which
+      # extractor writes which key).
+      METHOD_KEYS = %w[public_methods instance_methods class_methods].freeze
+
+      COVERAGE_VIA = 'test_coverage'
+
+      # @!attribute method
+      #   @return [String] the method name, `self.`-prefix stripped
+      # @!attribute kind
+      #   @return [Symbol] `:instance` or `:class`
+      # @!attribute from_unit
+      #   @return [String] identifier that lost the method
+      # @!attribute to_unit
+      #   @return [String] identifier that gained the method
+      # @!attribute covered_before
+      #   @return [Boolean] whether `from_unit` had a `:test_coverage` edge before
+      # @!attribute covered_after
+      #   @return [Boolean] whether `to_unit` has a `:test_coverage` edge after
+      # rubocop:disable Lint/StructNewOverride -- :method is the field name docs and callers already use
+      Finding = Struct.new(:method, :kind, :from_unit, :to_unit, :covered_before, :covered_after, keyword_init: true) do
+        # rubocop:enable Lint/StructNewOverride
+        # @return [Hash] symbol-keyed, ready for JSON
+        def to_h
+          { method: method, kind: kind, from_unit: from_unit, to_unit: to_unit,
+            covered_before: covered_before, covered_after: covered_after }
+        end
+      end
+
+      # @param before [Woods::PublishedIndex] the older generation
+      # @param after [Woods::PublishedIndex] the newer generation
+      def initialize(before:, after:)
+        @before = before
+        @after = after
+      end
+
+      # @return [Array<Finding>] sorted by method, then kind, then source, then destination
+      def run
+        removed, added = method_moves
+        covered_before = covered_units(@before)
+        covered_after = covered_units(@after)
+
+        removed.keys.sort_by { |name, kind| [name, kind.to_s] }.flat_map do |signature|
+          destinations = added[signature]
+          next [] unless destinations
+
+          build_findings(signature, removed[signature], destinations, covered_before, covered_after)
+        end
+      end
+
+      private
+
+      # @param signature [Array(String, Symbol)] `[method_name, kind]`
+      # @param sources [Array<Array(String, String)>] `[identifier, type]` units that lost it
+      # @param destinations [Array<Array(String, String)>] `[identifier, type]` units that gained it
+      # @param covered_before [Set<String>]
+      # @param covered_after [Set<String>]
+      # @return [Array<Finding>]
+      def build_findings(signature, sources, destinations, covered_before, covered_after)
+        name, kind = signature
+
+        sources.sort.product(destinations.sort).filter_map do |(from_unit, _from_type), (to_unit, _to_type)|
+          next if from_unit == to_unit
+
+          finding = Finding.new(method: name, kind: kind, from_unit: from_unit, to_unit: to_unit,
+                                covered_before: covered_before.include?(from_unit),
+                                covered_after: covered_after.include?(to_unit))
+          finding if finding.covered_before && !finding.covered_after
+        end
+      end
+
+      # @return [Array(Hash, Hash)] `[method_kind, unit] => units that lost/gained it`
+      def method_moves
+        before_methods = method_index(@before)
+        after_methods = method_index(@after)
+        [signature_losses(before_methods, after_methods), signature_losses(after_methods, before_methods)]
+      end
+
+      # Signatures a `[identifier, type]` unit has in +from+ but not in +to+,
+      # grouped by signature. "Removed" and "added" are the same computation
+      # with the two method-index hashes swapped, so both come from this one
+      # method.
+      #
+      # @param from [Hash{Array(String, String) => Set}]
+      # @param to [Hash{Array(String, String) => Set}]
+      # @return [Hash{Array(String, Symbol) => Array<Array(String, String)>}]
+      def signature_losses(from, to)
+        losses = Hash.new { |hash, key| hash[key] = [] }
+        (from.keys | to.keys).each do |unit_key|
+          lost = (from[unit_key] || Set.new) - (to[unit_key] || Set.new)
+          lost.each { |signature| losses[signature] << unit_key }
+        end
+        losses
+      end
+
+      # `[identifier, type]` => Set of `[name, kind]` signatures, for units
+      # that list any.
+      #
+      # Keyed on `[identifier, type]`, not identifier alone: an identifier a
+      # model and a service both use would otherwise resolve through
+      # `reader.unit(identifier)`'s untyped, collision-prone lookup, and the
+      # second entry processed would overwrite the first's slot in this hash.
+      # Typed lookup and a composite key keep each unit's own method list
+      # under its own type.
+      #
+      # @param reader [Woods::PublishedIndex]
+      # @return [Hash{Array(String, String) => Set<Array(String, Symbol)>}]
+      def method_index(reader)
+        reader.units.each_with_object({}) do |entry, index|
+          data = reader.unit(entry['identifier'], type: entry['type'])
+          next unless data
+
+          signatures = METHOD_KEYS.flat_map { |key| normalized_signatures(key, data.dig('metadata', key)) }
+          index[[entry['identifier'], entry['type']]] = signatures.to_set if signatures.any?
+        end
+      end
+
+      # Normalizes a raw metadata method name into a `[name, kind]` signature.
+      #
+      # `public_methods` (regex-extracted) mixes instance and class methods in
+      # one list, marking a class method with a literal `self.` prefix.
+      # `class_methods` and `instance_methods` are already split by key, with
+      # no prefix on the name. Normalizing both shapes to the same
+      # `[name, kind]` pair is what lets a `self.build` in one unit's
+      # `public_methods` match a bare `build` in another unit's
+      # `class_methods`, and, just as importantly, keeps an instance method
+      # from matching a class method of the same bare name.
+      #
+      # @param key [String] the metadata key the names came from
+      # @param names [Array<String>, nil]
+      # @return [Array<Array(String, Symbol)>]
+      def normalized_signatures(key, names)
+        Array(names).map do |raw|
+          name = raw.to_s
+          if name.start_with?('self.')
+            [name.delete_prefix('self.'), :class]
+          else
+            [name, key == 'class_methods' ? :class : :instance]
+          end
+        end
+      end
+
+      # @param reader [Woods::PublishedIndex]
+      # @return [Set<String>] identifiers some test_mapping unit covers
+      def covered_units(reader)
+        reader.edges(via: COVERAGE_VIA).to_set { |edge| edge[:to] }
+      end
+    end
+  end
+end

data/lib/woods/chunking/semantic_chunker.rb

@@ -29,6 +29,123 @@ module Woods
       end
     end
 
+    # Shared line-level Ruby block accounting for the chunkers in this
+    # file (B-083 / #195). Mirrors the proven heuristic in
+    # Woods::Extractors::RakeTaskExtractor#block_opener? — credit to that
+    # implementation for the "modifier keywords only count in statement
+    # position" rule (`return if x` must not open a block). Copied rather
+    # than shared so the extractor and the chunkers stay independent.
+    #
+    # Known limitations (deliberate — this is a line classifier, not a
+    # parser): heredoc and multi-line string bodies whose lines look like
+    # keywords (`<<~SQL` containing a bare `end` or a leading `case`)
+    # will skew the depth count, multi-line brace blocks (`{ ... }`) are
+    # not tracked, and a trailing comment containing `do`/`end` on the
+    # same line as real code can miscount. The AST layer
+    # (Woods::Ast) is the right tool when exactness matters.
+    module LineDepthTracking
+      # Multi-line `do` block opener — `items.each do |item|`. Anchored
+      # to end-of-line (optionally through block args and a trailing
+      # comment) so prose containing "do" mid-line doesn't count.
+      DO_BLOCK_PATTERN = /\bdo\s*(?:\|[^|]*\|)?\s*(?:#.*)?\z/
+
+      # Keywords that open an `end`-terminated body only in statement
+      # position: at line start, or directly after an assignment
+      # (`status = if urgent?`, `@memo ||= begin`). Trailing modifier
+      # forms (`return if x`, `retry while busy?`) must not count, and
+      # ternaries / `case ... in` clauses never involve these keywords
+      # in statement position, so they add no depth.
+      STATEMENT_KEYWORD_PATTERN =
+        /(?:\A|=\s*)(?:if|unless|case|begin|while|until|for|def|class|module)\b/
+
+      # A line that begins with `end` closes one body — including the
+      # chained (`end.compact`) and modifier (`end while retry?`) forms.
+      # `(?!:)` excludes `end:` (a symbol hash key, legal despite the
+      # reserved word).
+      END_LINE_PATTERN = /\Aend\b(?!:)/
+
+      # `=begin` / `=end` block-comment markers. `=begin` matched the
+      # assignment-position keyword branch (its `=` satisfying `=\s*`) and
+      # counted as an opener, while `=end` matched neither opener nor
+      # {END_LINE_PATTERN} — a net +1 depth per block comment, after which
+      # the enclosing method never closed and every later method was
+      # appended to its chunk (STO-3).
+      BLOCK_COMMENT_MARKER_PATTERN = /\A=(?:begin|end)\b/
+
+      # Operator method names, longest-first so `<=>` wins over `<=`.
+      OPERATOR_METHOD_NAMES =
+        '<=>|===|==|=~|!~|!=|\[\]=|\[\]|\*\*|<<|>>|<=|>=|[+-]@|[+\-*\/%<>&|^~!]'
+
+      # Name of an operator method definition (`def ==(other)`).
+      OPERATOR_DEF_NAME_PATTERN = /\A\s*def\s+(?:self\s*\.\s*)?(#{OPERATOR_METHOD_NAMES})/
+
+      # Endless (Ruby 3.0+) method definition: `def show = head :ok`.
+      # The endless marker is an `=` AFTER the method name and optional
+      # parameter list — `def ==(other)` and `def x=(v)` are ordinary
+      # defs whose *name* contains `=`, and both open a body. The
+      # marker's `=` must follow whitespace or a closing paren, which
+      # also keeps the rare space-form setter (`def x= v`) classified
+      # as a normal def. Limitation: a parameter default containing
+      # `)` (`def f(a = (1)) = a`) is misread as a normal def.
+      ENDLESS_DEF_PATTERN = /
+        \A \s* def \s+
+        (?: self \s* \. \s* )?
+        (?: #{OPERATOR_METHOD_NAMES}
+          | \w+ = (?= \s* \( )   # setter name (`def x=(v)`) — `=` is part of the name
+          | \w+ [?!]?            # plain name, may end with ? or !
+        )
+        (?: \s* \( [^)]* \) \s* | \s+ )
+        = \s* \S
+      /x
+
+      private
+
+      # Does this line open a block that a later `end` will close?
+      #
+      # @param line [String] raw source line
+      # @return [Boolean]
+      def block_opener?(line)
+        stripped = line.strip
+        return false if stripped.empty? || stripped.start_with?('#')
+        return false if stripped.match?(BLOCK_COMMENT_MARKER_PATTERN)
+        return false if endless_def?(stripped)
+        # An opener whose `end` sits on the same line is self-balancing
+        # (`if x then y end`) — count neither side.
+        return false if stripped.match?(/\bend\s*\z/)
+
+        stripped.match?(STATEMENT_KEYWORD_PATTERN) || stripped.match?(DO_BLOCK_PATTERN)
+      end
+
+      # Does this line close a block (`end`, `end.compact`, `end while x`)?
+      #
+      # @param line [String] raw source line
+      # @return [Boolean]
+      def block_terminator?(line)
+        line.strip.match?(END_LINE_PATTERN)
+      end
+
+      # Is this line an endless method definition (`def show = head :ok`)?
+      # Endless defs have no body and no closing `end`, so they must
+      # never enter method-tracking state or contribute depth.
+      #
+      # @param line [String] raw source line
+      # @return [Boolean]
+      def endless_def?(line)
+        line.match?(ENDLESS_DEF_PATTERN)
+      end
+
+      # Extract an operator method name (`==`, `<=>`, `[]`) from a def
+      # line. Fallback for the chunkers' `\w+`-based name extraction —
+      # without it `current_method` is set to nil (falsy), tracking never
+      # engages, and the operator method's body leaks out of its chunk.
+      #
+      # @param line [String] raw source line
+      # @return [String, nil] the operator name, or nil for non-operator defs
+      def operator_def_name(line)
+        line[OPERATOR_DEF_NAME_PATTERN, 1]
+      end
+    end
+
     # Class-like unit types that MethodChunker handles — anything
     # shaped as "class or module with public methods, maybe privates,
     # maybe callbacks/filters." Extend this list when new extractors
@@ -298,6 +415,7 @@ module Woods
     # @api private
     class ModelChunker
       include ChunkBuilder
+      include LineDepthTracking
 
       ASSOCIATION_PATTERN = /^\s*(has_many|has_one|belongs_to|has_and_belongs_to_many)\b/
       VALIDATION_PATTERN = /^\s*validates?\b/
@@ -370,12 +488,15 @@ module Woods
       def track_method_line(state, line)
         state[:sections][:methods] << line
         update_method_depth(state, line)
-        state[:in_method] = false if state[:depth] <= 0 && line.strip.match?(/^end\s*$/)
+        state[:in_method] = false if state[:depth] <= 0 && block_terminator?(line)
       end
 
+      # Balance nested blocks (`do`, multi-line `if`/`unless`/`case`/
+      # `begin`/`while`/`until`, nested `def`) so a nested `end` doesn't
+      # close the method early (B-083 / #195).
       def update_method_depth(state, line)
-        state[:depth] += 1 if line.match?(/\bdo\b|\bdef\b/) && !line.match?(/\bend\b/)
-        state[:depth] -= 1 if line.strip == 'end' || (line.match?(/\bend\s*$/) && state[:depth].positive?)
+        state[:depth] += 1 if block_opener?(line)
+        state[:depth] -= 1 if block_terminator?(line)
       end
 
       # Classify a single non-method line.
@@ -404,9 +525,14 @@ module Woods
       end
 
       def start_method(state, line)
+        state[:sections][:methods] << line
+        # An endless def (`def title = super&.strip`) has no body and no
+        # closing `end` — entering tracking state for it would swallow
+        # every subsequent line into :methods.
+        return if endless_def?(line)
+
         state[:in_method] = true
         state[:depth] = 1
-        state[:sections][:methods] << line
       end
 
       def assign_fallback(state, line)
@@ -424,8 +550,7 @@ module Woods
     # @api private
     class ControllerChunker
       include ChunkBuilder
-
-      FILTER_PATTERN = /^\s*(before_action|after_action|around_action|skip_before_action)\b/
+      include LineDepthTracking
 
       # @param unit [ExtractedUnit]
       def initialize(unit)
@@ -458,10 +583,13 @@ module Woods
         state
       end
 
+      # While inside an action body, collect every line and balance
+      # nested blocks (`do`, multi-line `if`/`case`/…) so a nested `end`
+      # doesn't close the action early (B-083 / #195).
       def track_action_line(state, line)
         state[:actions][state[:current_action]] << line
-        state[:depth] += 1 if line.match?(/\bdo\b/) && !line.match?(/\bend\b/)
-        return unless line.strip.match?(/^end\s*$/)
+        state[:depth] += 1 if block_opener?(line)
+        return unless block_terminator?(line)
 
         state[:depth] -= 1
         return unless state[:depth] <= 0
@@ -482,10 +610,18 @@ module Woods
       end
 
       def start_action(state, line)
-        action_name = line[/def\s+(\w+)/, 1]
+        # Capture an optional `self.` so a class method chunks under
+        # `self.<name>` instead of every one landing on the key "self"
+        # and clobbering the previous class method's collected lines.
+        action_name = line[/def\s+((?:self\.)?\w+)/, 1]
+        state[:actions][action_name] = [line]
+        # An endless def (`def show = head :ok`) is a complete action on
+        # its own line — no body follows, so entering tracking state
+        # would swallow every subsequent action into this chunk.
+        return if endless_def?(line)
+
         state[:current_action] = action_name
         state[:depth] = 1
-        state[:actions][action_name] = [line]
       end
 
       # @param state [Hash]
@@ -520,6 +656,7 @@ module Woods
     # @api private
     class MethodChunker
       include ChunkBuilder
+      include LineDepthTracking
 
       # @param unit [ExtractedUnit]
       def initialize(unit)
@@ -555,15 +692,15 @@ module Woods
       end
 
       # While inside a method body, collect every line and track depth so
-      # we know when the method closes. Blocks (`do...end`, `if...end`)
-      # nest inside methods and must be balanced before the method's own
-      # `end` line counts.
+      # we know when the method closes. Blocks (`do...end`, multi-line
+      # `if...end`, `case...end`, …) nest inside methods and must be
+      # balanced before the method's own `end` line counts (B-083 / #195).
       def track_method_line(state, line)
         target = state[:in_private] ? state[:private_methods] : state[:methods][state[:current_method]]
         target << line
 
-        state[:depth] += 1 if line.match?(/\bdo\b/) && !line.match?(/\bend\b/)
-        return unless line.strip.match?(/^end\s*$/)
+        state[:depth] += 1 if block_opener?(line)
+        return unless block_terminator?(line)
 
         state[:depth] -= 1
         return unless state[:depth] <= 0
@@ -588,9 +725,7 @@ module Woods
       end
 
       def start_method(state, line)
-        method_name = line[/def\s+(?:self\.)?(\w+)/, 1]
-        state[:current_method] = method_name
-        state[:depth] = 1
+        method_name = line[/def\s+(?:self\.)?(\w+)/, 1] || operator_def_name(line)
 
         if state[:in_private]
           state[:private_methods] << line
@@ -600,6 +735,13 @@ module Woods
           # methods in source order.
           state[:methods][method_name] = [line]
         end
+
+        # An endless def (`def ping = :pong`) is complete on its own line
+        # — entering tracking state would swallow every later method.
+        return if endless_def?(line)
+
+        state[:current_method] = method_name
+        state[:depth] = 1
       end
 
       # Build the final chunk array from the parse state.

data/lib/woods/console/audit_logger.rb

@@ -44,11 +44,17 @@ module Woods
       def log(tool:, params:, confirmed:, result_summary:)
         ensure_directory!
 
+        # Redact BEFORE truncating (CON-5). Truncation cuts at
+        # MAX_FIELD_CHARS, and a credential straddling that boundary is split
+        # in two: the scanner's word-boundary/length-anchored patterns no
+        # longer match the surviving prefix, so cleartext `sk_live_…` reached
+        # the JSONL. Scanning the whole value first means the boundary can
+        # only ever fall inside `[REDACTED]`.
         entry = {
           tool: tool,
-          params: redact(truncate_deep(params)),
+          params: truncate_deep(redact(params)),
           confirmed: confirmed,
-          result_summary: redact(truncate_value(result_summary)),
+          result_summary: truncate_value(redact(result_summary)),
           timestamp: Time.now.utc.iso8601
         }
 
@@ -121,7 +127,10 @@ module Woods
       def entries
         return [] unless File.exist?(@path)
 
-        File.readlines(@path).filter_map do |line|
+        # Explicit UTF-8: entries are written as UTF-8 (the truncation notice
+        # alone carries a multibyte ellipsis), so a bare read would tag them
+        # with the process default external encoding and raise under LANG=C.
+        File.readlines(@path, encoding: Encoding::UTF_8).filter_map do |line|
           JSON.parse(line.strip) unless line.strip.empty?
         end
       end

data/lib/woods/console/bridge_protocol.rb

@@ -2,27 +2,16 @@
 
 module Woods
   module Console
-    # Canonical console-tool protocol contract shared by {StubBridge}
-    # (the JSON-lines scaffold) and {EmbeddedExecutor} (the in-process
-    # executor that ships today). The eventual real bridge-process
-    # implementation (Option D — see `docs/design/CONSOLE_SERVER.md`)
-    # will also reference this module so every executor that speaks the
-    # protocol agrees on the tool vocabulary.
+    # Canonical Tier 1 vocabulary used by {EmbeddedExecutor}. The historical
+    # name remains for compatibility after removal of the JSON-lines bridge.
     #
-    # Three constants live here:
+    # Two constants live here:
     #
     # - {SUPPORTED_TOOLS} — the canonical Tier 1 tool list.
     # - {TIER1_TOOLS}     — alias, kept as a distinct name for call
     #   sites that reason about tier semantics rather than the whole
     #   supported set.
-    # - {TOOL_HANDLERS}   — tool → `handle_<tool>` method-symbol map.
     #
-    # Previously these lived on {StubBridge} and {EmbeddedExecutor}
-    # borrowed them with `TIER1_TOOLS = StubBridge::TIER1_TOOLS`, which
-    # reads as "the real executor borrows constants from the stub" —
-    # backwards. Extracting the protocol here lets the real executor
-    # (and a future non-stub `Bridge` class) claim the contract without
-    # importing the scaffold.
     module BridgeProtocol
       SUPPORTED_TOOLS = %w[
         count
@@ -37,8 +26,6 @@ module Woods
       ].freeze
 
       TIER1_TOOLS = SUPPORTED_TOOLS
-
-      TOOL_HANDLERS = SUPPORTED_TOOLS.to_h { |t| [t, :"handle_#{t}"] }.freeze
     end
   end
 end