RubyGems - fosm-rails-coding-agent - Versions diffs - 0.0.1 - Mend

fosm-rails-coding-agent 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

checksums.yaml +7 -0
data/AGENTS.md +77 -0
data/CHANGELOG.md +16 -0
data/LICENSE +127 -0
data/README.md +135 -0
data/bin/fosm-coding-agent +14 -0
data/lib/fosm_rails_coding_agent/acp_agent.rb +132 -0
data/lib/fosm_rails_coding_agent/configuration.rb +27 -0
data/lib/fosm_rails_coding_agent/exceptions_middleware.rb +67 -0
data/lib/fosm_rails_coding_agent/middleware.rb +115 -0
data/lib/fosm_rails_coding_agent/quiet_middleware.rb +18 -0
data/lib/fosm_rails_coding_agent/railtie.rb +51 -0
data/lib/fosm_rails_coding_agent/tools/base.rb +10 -0
data/lib/fosm_rails_coding_agent/tools/execute_sql.rb +44 -0
data/lib/fosm_rails_coding_agent/tools/fosm/available_events.rb +46 -0
data/lib/fosm_rails_coding_agent/tools/fosm/fire_event.rb +46 -0
data/lib/fosm_rails_coding_agent/tools/fosm/inspect_lifecycle.rb +44 -0
data/lib/fosm_rails_coding_agent/tools/fosm/list_lifecycles.rb +45 -0
data/lib/fosm_rails_coding_agent/tools/fosm/model_resolver.rb +25 -0
data/lib/fosm_rails_coding_agent/tools/fosm/transition_history.rb +56 -0
data/lib/fosm_rails_coding_agent/tools/fosm/why_blocked.rb +36 -0
data/lib/fosm_rails_coding_agent/tools/get_docs.rb +58 -0
data/lib/fosm_rails_coding_agent/tools/get_logs.rb +66 -0
data/lib/fosm_rails_coding_agent/tools/get_models.rb +35 -0
data/lib/fosm_rails_coding_agent/tools/get_source_location.rb +69 -0
data/lib/fosm_rails_coding_agent/tools/project_eval.rb +76 -0
data/lib/fosm_rails_coding_agent/transport.rb +84 -0
data/lib/fosm_rails_coding_agent/version.rb +5 -0
data/lib/fosm_rails_coding_agent.rb +26 -0
metadata +139 -0

data/lib/fosm_rails_coding_agent/middleware.rb ADDED Viewed

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+require "ipaddr"
+require "fast_mcp"
+require "rack/request"
+require "json"
+require_relative "transport"
+module FosmRailsCodingAgent
+  # Rack middleware that serves the FosmRailsCodingAgent MCP server.
+  # Handles tool registration, localhost enforcement, and MCP routing.
+  # FOSM tools are registered conditionally when fosm-rails is detected.
+  class Middleware
+    ROUTE_PREFIX = "fosm-agent"
+    MCP_ROUTE    = "mcp"
+    REMOTE_BLOCKED = <<~MSG.freeze
+      FosmRailsCodingAgent does not accept remote connections by default.
+      Set config.fosm_coding_agent.allow_remote_access = true if you need this.
+    MSG
+    def initialize(app, config)
+      @allow_remote = config.allow_remote_access
+      @project_name = Rails.application.class.module_parent.name
+      @app = FastMcp.rack_middleware(app,
+        name:           "fosm-rails-coding-agent",
+        version:        FosmRailsCodingAgent::VERSION,
+        path_prefix:    "/#{ROUTE_PREFIX}/#{MCP_ROUTE}",
+        transport:      FosmRailsCodingAgent::Transport,
+        logger:         config.logger || Logger.new(Rails.root.join("log", "fosm-coding-agent.log")),
+        allowed_origins: [],
+        localhost_only:  false
+      ) do |server|
+        # Register core tools (always available)
+        core_tools = FosmRailsCodingAgent::Tools::Base.descendants.reject do |tool|
+          tool.module_parents.include?(FosmRailsCodingAgent::Tools::Fosm)
+        end
+        server.register_tools(*core_tools)
+        # Register FOSM tools only when fosm-rails is loaded
+        if FosmRailsCodingAgent.fosm_available?
+          fosm_tools = FosmRailsCodingAgent::Tools::Base.descendants.select do |tool|
+            tool.module_parents.include?(FosmRailsCodingAgent::Tools::Fosm)
+          end
+          server.register_tools(*fosm_tools) if fosm_tools.any?
+        end
+      end
+    end
+    def call(env)
+      request = Rack::Request.new(env)
+      path    = request.path.split("/").reject(&:empty?)
+      if path.first == ROUTE_PREFIX
+        return forbidden(REMOTE_BLOCKED) unless local_ip?(request)
+        case [request.request_method, path]
+        when ["GET", [ROUTE_PREFIX]]
+          return home_page
+        when ["GET", [ROUTE_PREFIX, "config"]]
+          return config_endpoint
+        end
+      end
+      status, headers, body = @app.call(env)
+      headers.delete("X-Frame-Options")
+      [status, headers, body]
+    end
+    private
+    def home_page
+      [200, { "Content-Type" => "text/html" }, [<<~HTML]]
+        <!DOCTYPE html>
+        <html>
+        <head><meta charset="UTF-8"><title>FosmRailsCodingAgent</title></head>
+        <body>
+          <h1>FosmRailsCodingAgent</h1>
+          <p>FOSM-aware runtime intelligence is active.</p>
+          <p>MCP endpoint: <code>/fosm-agent/mcp</code></p>
+          <p>FOSM: #{FosmRailsCodingAgent.fosm_available? ? "detected" : "not detected"}</p>
+          <p>Project: #{@project_name}</p>
+        </body>
+        </html>
+      HTML
+    end
+    def config_endpoint
+      [200, { "Content-Type" => "application/json" }, [JSON.generate({
+        project_name:    @project_name,
+        framework:       "rails",
+        fosm_agent_version: FosmRailsCodingAgent::VERSION,
+        fosm_available:  FosmRailsCodingAgent.fosm_available?
+      })]]
+    end
+    def forbidden(message)
+      Rails.logger.warn(message)
+      [403, { "Content-Type" => "text/plain" }, [message]]
+    end
+    def local_ip?(request)
+      return true if @allow_remote
+      addr = IPAddr.new(request.ip.to_s)
+      addr.loopback? ||
+        addr == IPAddr.new("127.0.0.1") ||
+        addr == IPAddr.new("::1") ||
+        addr == IPAddr.new("::ffff:127.0.0.1")
+    rescue IPAddr::InvalidAddressError
+      false
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/quiet_middleware.rb ADDED Viewed

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  # Suppresses FosmRailsCodingAgent request noise from the Rails development log.
+  class QuietMiddleware
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      if env["PATH_INFO"].start_with?("/fosm-agent")
+        Rails.logger.silence { @app.call(env) }
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/railtie.rb ADDED Viewed

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "logger"
+require "fosm_rails_coding_agent/configuration"
+require "fosm_rails_coding_agent/middleware"
+require "fosm_rails_coding_agent/exceptions_middleware"
+require "fosm_rails_coding_agent/quiet_middleware"
+# Load all tools
+Dir[File.expand_path("tools/**/*.rb", __dir__)].each { |f| require f }
+module FosmRailsCodingAgent
+  # Railtie that wires FosmRailsCodingAgent into the Rails middleware stack.
+  # Refuses to load in production (requires config.enable_reloading).
+  # Sets up MCP server middleware and optionally starts the ACP agent.
+  class Railtie < Rails::Railtie
+    config.fosm_coding_agent = FosmRailsCodingAgent::Configuration.new
+    initializer "fosm_coding_agent.setup" do |app|
+      unless app.config.enable_reloading
+        raise "fosm-rails-coding-agent is a development tool. It requires config.enable_reloading = true."
+      end
+      app.config.middleware.insert_after(
+        ActionDispatch::Callbacks,
+        FosmRailsCodingAgent::Middleware,
+        app.config.fosm_coding_agent
+      )
+    end
+    initializer "fosm_coding_agent.intercept_exceptions" do |app|
+      ActionDispatch::DebugExceptions.register_interceptor do |request, exception|
+        request.set_header("fosm_agent.exception", exception)
+      end
+      app.middleware.insert_before(ActionDispatch::DebugExceptions, FosmRailsCodingAgent::ExceptionsMiddleware)
+    end
+    initializer "fosm_coding_agent.quiet_logging" do |app|
+      app.middleware.insert_before(Rails::Rack::Logger, FosmRailsCodingAgent::QuietMiddleware)
+    end
+    initializer "fosm_coding_agent.acp_agent" do |app|
+      next unless app.config.fosm_coding_agent.acp_enabled
+      # Register the ACP agent binary path so clients can discover it
+      agent_binary = File.expand_path("../../bin/fosm-agent-agent", __dir__)
+      Rails.logger&.info("[FosmRailsCodingAgent] ACP agent available at: #{agent_binary}")
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/base.rb ADDED Viewed

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  module Tools
+    # Base class for all FosmRailsCodingAgent MCP tools.
+    # Inherits FastMcp::Tool DSL: tool_name, description, arguments, call.
+    class Base < FastMcp::Tool
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/execute_sql.rb ADDED Viewed

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  module Tools
+    # Executes SQL queries against the application database.
+    # Results are capped at the configured row limit (default 50).
+    class ExecuteSql < Base
+      tool_name "execute_sql"
+      description <<~DESC
+        Executes the given SQL query against the application database.
+        Results are limited to #{FosmRailsCodingAgent::Configuration.new.sql_row_limit} rows.
+        Use LIMIT/OFFSET for pagination. Select only the columns you need.
+        For PostgreSQL, use $1, $2 for parameter placeholders.
+        For MySQL, use ? for parameter placeholders.
+      DESC
+      arguments do
+        required(:query).filled(:string).description("The SQL query to execute")
+        optional(:arguments).value(:array).description("Bind parameters for the query placeholders")
+      end
+      def @input_schema.json_schema
+        schema = super
+        schema[:properties][:arguments][:items] = {}
+        schema
+      end
+      def call(query:, arguments: [])
+        result = ActiveRecord::Base.connection.exec_query(query, "FOSM Agent SQL", arguments)
+        limit  = FosmRailsCodingAgent.config.sql_row_limit
+        {
+          columns:   result.columns,
+          rows:      result.rows.first(limit),
+          row_count: result.rows.size,
+          truncated: result.rows.size > limit,
+          adapter:   ActiveRecord::Base.connection.adapter_name,
+          database:  ActiveRecord::Base.connection.current_database
+        }
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/available_events.rb ADDED Viewed

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "json"
+require_relative "model_resolver"
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Lists events that can be fired from a record's current state,
+      # considering both transition validity and guard evaluation.
+      class AvailableEvents < FosmRailsCodingAgent::Tools::Base
+        include FosmRailsCodingAgent::Tools::Fosm::ModelResolver
+        tool_name "fosm_available_events"
+        description <<~DESC
+          Returns events that can fire right now on a FOSM record.
+          Checks current state, transition rules, and guard conditions.
+          Always call this before firing an event.
+        DESC
+        arguments do
+          required(:model).filled(:string).description("Model class name, e.g. 'Invoice'")
+          required(:id).filled(:integer).description("Record ID")
+        end
+        def call(model:, id:)
+          klass = resolve_model(model)
+          record = klass.find(id)
+          lifecycle = klass.fosm_lifecycle
+          available = record.available_events
+          events_detail = available.map do |event_name|
+            event_def = lifecycle.find_event(event_name)
+            { name: event_name, to_state: event_def.to_state }
+          end
+          JSON.generate({
+            model: klass.name,
+            id: record.id,
+            current_state: record.state,
+            available_events: events_detail
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/fire_event.rb ADDED Viewed

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "json"
+require_relative "model_resolver"
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Fires a FOSM lifecycle event on a record.
+      # Always uses actor: :agent for audit trail attribution.
+      class FireEvent < FosmRailsCodingAgent::Tools::Base
+        include FosmRailsCodingAgent::Tools::Fosm::ModelResolver
+        tool_name "fosm_fire_event"
+        description <<~DESC
+          Fires a lifecycle event on a FOSM record.
+          The event is attributed to actor: :agent in the audit trail.
+          Always check available_events first to avoid errors.
+        DESC
+        arguments do
+          required(:model).filled(:string).description("Model class name, e.g. 'Invoice'")
+          required(:id).filled(:integer).description("Record ID")
+          required(:event).filled(:string).description("Event name to fire, e.g. 'send_invoice'")
+          optional(:metadata).filled(:hash).description("Optional metadata for the transition log")
+        end
+        def call(model:, id:, event:, metadata: {})
+          klass = resolve_model(model)
+          record = klass.find(id)
+          record.fire!(event.to_sym, actor: :agent, metadata: metadata)
+          JSON.generate({
+            success: true,
+            model: klass.name,
+            id: record.id,
+            event: event,
+            new_state: record.state,
+            available_events: record.available_events
+          })
+        rescue ::Fosm::Error => e
+          JSON.generate({ success: false, error: e.message })
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/inspect_lifecycle.rb ADDED Viewed

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require "json"
+require_relative "model_resolver"
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Deep introspection of a single FOSM lifecycle: states, events,
+      # guards, side effects, access rules, and diagram data.
+      class InspectLifecycle < FosmRailsCodingAgent::Tools::Base
+        include FosmRailsCodingAgent::Tools::Fosm::ModelResolver
+        tool_name "fosm_inspect_lifecycle"
+        description <<~DESC
+          Deep introspection of one FOSM lifecycle model class.
+          Returns states, events with transitions, guards, side effects,
+          access control rules, snapshot configuration, and diagram data.
+        DESC
+        arguments do
+          required(:model).filled(:string).description("The model class name, e.g. 'Invoice' or 'Fosm::Invoice'")
+        end
+        def call(model:)
+          klass = resolve_model(model)
+          lifecycle = klass.fosm_lifecycle
+          raise "#{klass.name} has no FOSM lifecycle defined" unless lifecycle
+          result = {
+            model: klass.name,
+            states: inspect_states(lifecycle),
+            events: inspect_events(lifecycle),
+            diagram: lifecycle.to_diagram_data
+          }
+          result[:access] = inspect_access(lifecycle) if lifecycle.access_defined?
+          result[:snapshots] = inspect_snapshots(lifecycle) if lifecycle.snapshot_configured?
+          JSON.pretty_generate(result)
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/list_lifecycles.rb ADDED Viewed

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Lists all FOSM lifecycle model classes registered in the application,
+      # with a summary of their states, events, and guards.
+      class ListLifecycles < FosmRailsCodingAgent::Tools::Base
+        tool_name "fosm_list_lifecycles"
+        description <<~DESC
+          Lists all FOSM lifecycle model classes in the application.
+          Returns each model with its states, events, and guard names.
+          Use this to discover what state machines exist in the project.
+        DESC
+        def call
+          models = ::Fosm::Registry.model_classes
+          return "No FOSM lifecycles found" if models.empty?
+          models.map do |klass|
+            lifecycle = klass.fosm_lifecycle
+            next unless lifecycle
+            states = lifecycle.states.map do |s|
+              name = s.name.to_s
+              name += " (initial)" if s.initial?
+              name += " (terminal)" if s.terminal?
+              name
+            end
+            events = lifecycle.events.map do |e|
+              guards = e.guards.map(&:name).join(", ")
+              desc = "#{e.name}: #{e.from_states.join(", ")} → #{e.to_state}"
+              desc += " [guards: #{guards}]" if guards.present?
+              desc
+            end
+            "## #{klass.name}\nStates: #{states.join(", ")}\nEvents:\n#{events.map { |e| "  - #{e}" }.join("\n")}"
+          end.compact.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/model_resolver.rb ADDED Viewed

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Shared model resolution logic for FOSM tools.
+      # Tries direct constant lookup, Fosm:: prefix, and Registry search.
+      module ModelResolver
+        private
+        def resolve_model(name)
+          Object.const_get(name)
+        rescue NameError
+          begin
+            Object.const_get("Fosm::#{name}")
+          rescue NameError
+            found = ::Fosm::Registry.model_classes.find { |k| k.name.demodulize == name }
+            raise NameError, "FOSM model '#{name}' not found. Use fosm_list_lifecycles to discover available models." unless found
+            found
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/transition_history.rb ADDED Viewed

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require "json"
+require_relative "model_resolver"
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Returns the audit trail of state transitions for a FOSM record.
+      class TransitionHistory < FosmRailsCodingAgent::Tools::Base
+        include FosmRailsCodingAgent::Tools::Fosm::ModelResolver
+        tool_name "fosm_transition_history"
+        description <<~DESC
+          Returns the transition audit trail for a FOSM record.
+          Shows each state change with event, actor, timestamp, and metadata.
+        DESC
+        arguments do
+          required(:model).filled(:string).description("Model class name, e.g. 'Invoice'")
+          required(:id).filled(:integer).description("Record ID")
+          optional(:limit).filled(:integer).description("Max transitions to return (default: 50)")
+        end
+        def call(model:, id:, limit: 50)
+          klass = resolve_model(model)
+          record = klass.find(id)
+          logs = ::Fosm::TransitionLog
+            .where(record_type: klass.name, record_id: record.id.to_s)
+            .order(created_at: :desc)
+            .limit(limit)
+          result = {
+            model: klass.name,
+            id: record.id,
+            current_state: record.state,
+            transitions: logs.map do |log|
+              entry = {
+                event: log.event_name,
+                from: log.from_state,
+                to: log.to_state,
+                actor: log.actor_label || log.actor_type,
+                at: log.created_at.iso8601
+              }
+              entry[:metadata] = log.metadata if log.metadata.present?
+              entry[:snapshot] = true if log.state_snapshot.present?
+              entry
+            end
+          }
+          JSON.pretty_generate(result)
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/fosm/why_blocked.rb ADDED Viewed

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "json"
+require_relative "model_resolver"
+module FosmRailsCodingAgent
+  module Tools
+    module Fosm
+      # Explains why a specific event cannot fire on a record.
+      # Returns guard failures, invalid state, terminal state info, etc.
+      class WhyBlocked < FosmRailsCodingAgent::Tools::Base
+        include FosmRailsCodingAgent::Tools::Fosm::ModelResolver
+        tool_name "fosm_why_blocked"
+        description <<~DESC
+          Explains why a lifecycle event cannot fire on a FOSM record.
+          Returns detailed diagnostics: guard failures, invalid transitions,
+          terminal state blocks, and valid source states.
+        DESC
+        arguments do
+          required(:model).filled(:string).description("Model class name, e.g. 'Invoice'")
+          required(:id).filled(:integer).description("Record ID")
+          required(:event).filled(:string).description("Event name to diagnose, e.g. 'send_invoice'")
+        end
+        def call(model:, id:, event:)
+          klass = resolve_model(model)
+          record = klass.find(id)
+          result = record.why_cannot_fire?(event.to_sym)
+          JSON.pretty_generate(result)
+        end
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/get_docs.rb ADDED Viewed

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  module Tools
+    # Extracts documentation comments from above a constant or method definition.
+    # Relies on GetSourceLocation to find the source file and line.
+    class GetDocs < Base
+      tool_name "get_docs"
+      description <<~DESC
+        Returns documentation comments for a Ruby constant or method.
+        Examples: `String`, `String#gsub`, `File.executable?`
+        Works for project code and gem dependencies.
+        Prefer this over grepping when you know the exact reference.
+      DESC
+      arguments do
+        required(:reference).filled(:string).description("Constant or method to look up documentation for")
+      end
+      def call(reference:)
+        file_path, line_number = FosmRailsCodingAgent::Tools::GetSourceLocation.resolve(reference)
+        raise NameError, "could not find docs for #{reference}" unless file_path
+        extract_documentation(file_path, line_number) || "No documentation found for #{reference}"
+      end
+      private
+      def extract_documentation(file_path, line_number)
+        return nil unless File.exist?(file_path)
+        lines = File.readlines(file_path)
+        return nil if line_number <= 0 || line_number > lines.length
+        current_line = line_number - 2
+        comment_lines = []
+        while current_line >= 0
+          line = lines[current_line].chomp.strip
+          if line.start_with?("#")
+            comment_lines.unshift(line.sub(/^#\s?/, ""))
+          elsif line.empty?
+            # skip blank lines between comments
+          else
+            break
+          end
+          current_line -= 1
+        end
+        comment_lines.empty? ? nil : comment_lines.join("\n")
+      end
+    end
+  end
+end

data/lib/fosm_rails_coding_agent/tools/get_logs.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module FosmRailsCodingAgent
+  module Tools
+    # Tails the Rails development log with optional regex filtering.
+    class GetLogs < Base
+      tool_name "get_logs"
+      description <<~DESC
+        Returns recent log entries from the Rails development log.
+        Use this to check for request logs, errors, or debugging output.
+      DESC
+      arguments do
+        required(:tail).filled(:integer).description("Number of log lines to return from the end")
+        optional(:grep).filled(:string).description("Filter logs with a case-insensitive regex pattern")
+      end
+      def call(tail:, grep: nil)
+        log_file = Rails.root.join("log", "#{Rails.env}.log")
+        return "Log file not found" unless File.exist?(log_file)
+        regex = Regexp.new(grep, Regexp::IGNORECASE) if grep
+        matching_lines = []
+        tail_lines(log_file) do |line|
+          if regex.nil? || line.match?(regex)
+            matching_lines.unshift(line)
+            break if matching_lines.size >= tail
+          end
+        end
+        matching_lines.join
+      end
+      private
+      def tail_lines(file_path)
+        File.open(file_path, "rb") do |file|
+          file.seek(0, IO::SEEK_END)
+          file_size = file.pos
+          return if file_size == 0
+          buffer_size = [4096, file_size].min
+          pos = file_size
+          buffer = ""
+          while pos > 0 && buffer.count("\n") < 10_000
+            seek_pos = [pos - buffer_size, 0].max
+            file.seek(seek_pos)
+            chunk = file.read(pos - seek_pos)
+            buffer = chunk + buffer
+            pos = seek_pos
+            lines = buffer.split("\n")
+            buffer = pos > 0 && !buffer.start_with?("\n") ? (lines.shift || "") : ""
+            lines.reverse_each { |line| yield "#{line}\n" unless line.empty? }
+            break if pos == 0
+          end
+          yield "#{buffer}\n" unless buffer.empty?
+        end
+      end
+    end
+  end
+end