simple_english 0.6.0-x86_64-linux

data/lib/simple_english/daemon/server.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+# The se daemon: process lifecycle only. The wire protocol lives in
+# lib/simple_english/daemon/http.rb, the lint engine in
+# lib/simple_english/daemon/engine.rb.
+# Failures raise typed errors (PortInUse, SetupError, InnerDied,
+# InnerTimeout). bin/se owns turning them into warnings and exit codes.
+
+require "net/http"
+require "socket"
+require "tempfile"
+
+require_relative "../setup/install"
+require_relative "../client/daemon"
+require_relative "../setup/fingerprint"
+require_relative "../version"
+
+module SimpleEnglish
+  module Server
+    class ServerError < StandardError; end
+
+    class PortInUse < ServerError
+      def initialize(port)
+        super("port #{port} is already in use.")
+      end
+    end
+
+    class InnerDied < ServerError; end
+
+    class InnerTimeout < ServerError; end
+
+    module_function
+
+    # Probes both loopback families: on IPv6-first resolvers a "localhost"
+    # probe falls back to IPv4 and misses an IPv6 listener.
+    def assert_port_free(port)
+      raise PortInUse, port unless port_free?(port)
+    end
+
+    def port_free?(port)
+      ["127.0.0.1", "::1"].each do |address|
+        TCPServer.new(address, port).close
+      rescue Errno::EADDRNOTAVAIL, Errno::EAFNOSUPPORT
+        # One family may be missing on this host (EADDRNOTAVAIL, or
+        # EAFNOSUPPORT when the kernel has no IPv6 at all): skip it
+        # and probe the other. A rescue at method scope returns here
+        # and never probes the second family.
+        next
+      end
+      true
+    rescue Errno::EADDRINUSE
+      false
+    rescue Errno::EACCES
+      raise ServerError, "port #{port} cannot be bound. Use a port above 1024."
+    end
+
+    # `se serve` over a live daemon (gem upgrade): when
+    # one of our daemons holds the port (it answers the
+    # handshake), stop it and take over the port. A service that
+    # does not answer the handshake, pre-handshake daemon included,
+    # keeps the PortInUse error: those need a manual look.
+    def takeover(port)
+      daemon = Client.info(base_url: "http://localhost:#{port}")
+      return unless daemon.is_a?(Hash)
+      stop(daemon["pid"])
+      # The outer listener closes first. The inner server takes
+      # longer. Both ports must free, or the next boot hits the inner
+      # port and dies.
+      deadline = Time.now + 10
+      sleep 0.2 until Time.now > deadline ||
+          !Client.info(base_url: "http://localhost:#{port}").is_a?(Hash) &&
+              port_free?(port + 1)
+    end
+
+    # Graceful only. SIGKILL skips the TERM trap and the inner server
+    # teardown. The orphan still holds port + 1 and breaks the next
+    # boot. The pid comes off the wire, so only a positive integer is
+    # TERMed: 0 signals the caller's own process group, a negative
+    # one every process the user may signal.
+    def stop(pid)
+      return nil unless pid.is_a?(Integer) && pid > 1
+      Process.kill("TERM", pid)
+    rescue Errno::ESRCH, Errno::EPERM
+      nil
+    end
+
+    # Everything a boot needs on the machine, checked before the
+    # takeover stops the old daemon: a reload that cannot boot must
+    # leave the running daemon alive.
+    def preflight_install(install)
+      install.executable!
+    end
+    private_class_method :preflight_install
+
+    # `se serve --detached`: replace any se daemon on the port, then
+    # boot a plain foreground serve as a detached child - the same
+    # shape the auto-boot spawns. The parent returns once the
+    # handshake answers. nil means the child never came up, and the
+    # visible serve (same command, no flag) shows why. dev_log is
+    # forwarded so a detached daemon can still get a log file.
+    def start_detached(port: Client::DEFAULT_PORT, install: Install.from_env,
+      dev_log: nil)
+      preflight_install(install)
+      takeover(port)
+      # A foreign port holder survives the takeover untouched: fail
+      # in milliseconds like the foreground boot, not after the
+      # 90 s spawn timeout.
+      assert_port_free(port)
+      assert_port_free(port + 1)
+      args = ["--port", port.to_s]
+      args.concat(["--dev-log", dev_log]) if dev_log
+      pid = Client.spawn_daemon(*args)
+      # The child gives its inner server TIMEOUT_SECONDS to boot, and
+      # the handshake answers only after that: wait the child's own
+      # budget, not the default 90 s, or a slow boot reads as
+      # failure while the child is still coming up.
+      daemon = Client.wait_for(
+        seconds: SimpleEnglish::LanguageTool::TIMEOUT_SECONDS + 10
+      ) { Client.info(base_url: "http://localhost:#{port}") }
+      return daemon if daemon.is_a?(Hash)
+      # Readiness failed. The child is either dead (InnerTimeout and
+      # InnerDied make it exit itself) or a straggler that later
+      # takes over the port from whatever daemon comes next.
+      # Stop it either way, and reap so nothing is left behind.
+      stop(pid)
+      begin
+        Process.wait(pid)
+      rescue SystemCallError
+        # The child already exited on its own (InnerTimeout,
+        # InnerDied): only the reap is left.
+      end
+      nil
+    end
+
+    def start(port: Client::DEFAULT_PORT, install: Install.from_env, log: $stderr)
+      enabled_rules = SimpleEnglish::LanguageTool.rule_ids
+      daemon_info = {"version" => VERSION, "pid" => Process.pid,
+                     "gem_digest" => Fingerprint.gem,
+                     "rules_digest" => Fingerprint.sha(File.read(LanguageTool::RULES_FILE))}
+      # Preflight everything the replacement needs before the
+      # takeover stops the old daemon.
+      preflight_install(install)
+      takeover(port)
+      assert_port_free(port)
+      # The inner native server lives on port + 1. Guard it too so an occupied
+      # inner port raises in milliseconds instead of timing out later.
+      assert_port_free(port + 1)
+      # The inner native server's stderr goes to a file so failure messages can quote
+      # its first line. Only an explicitly opened dev log (a File) is reused
+      # for that. $stderr reports path "<STDERR>", so it creates a file
+      # by that name in the CWD. Anything else falls back to a temp file
+      # that Ruby unlinks when the process exits.
+      inner_log_path =
+        if log.is_a?(File)
+          log.path
+        else
+          inner_log = Tempfile.new("se-inner")
+          inner_log.close
+          inner_log.path
+        end
+      inner = spawn_inner(install: install, port: port + 1,
+        log_path: inner_log_path)
+      # TCPServer.new binds synchronously: construction means ready, so
+      # callers need no readiness polling. Closing the socket makes the
+      # serving loop's select raise and the loop exit.
+      server = TCPServer.new(port)
+      inner_died = false
+      # Closing the listening socket does not interrupt a syscall already
+      # blocked on the old fd, so the serving loop selects with a short
+      # timeout: the next IO.select on a closed socket raises IOError, so
+      # every shutdown path (trap, inner-death monitor) exits the loop
+      # within the timeout, on every platform.
+      stop_server = proc do
+        server.close
+      rescue IOError
+        # Already closed by another shutdown path.
+      end
+      # The monitor reaps the inner process, so nil it in the callback to
+      # keep the cleanup idempotent against the already-reaped pid.
+      monitor = monitor_inner(inner, on_death: proc do
+        inner = nil
+        inner_died = true
+        stop_server.call
+      end)
+      trap("INT") { stop_server.call }
+      trap("TERM") { stop_server.call }
+      (log.respond_to?(:puts) ? log : $stderr).puts "se listening on http://localhost:#{port}"
+      loop do
+        ready = IO.select([server], nil, nil, 0.5)
+        # Select timeout on an idle socket: loop back and select again.
+        next if ready.nil?
+        client = server.accept
+        Thread.new(client) { |c|
+          HTTP.handle_client(c, port: port,
+            enabled_rules: enabled_rules, info: daemon_info)
+        }
+      rescue IOError, Errno::EBADF
+        # A trap or the inner-death monitor closed the listener. This
+        # happens during the select, or between select and accept.
+        break
+      end
+      monitor.kill if monitor.alive?
+      raise InnerDied, "lint engine died. Rerun se serve." if inner_died
+    ensure
+      if inner
+        begin
+          Process.kill("TERM", inner)
+          Process.wait(inner)
+        rescue Errno::ESRCH, Errno::ECHILD
+          # The monitor thread already reaped the inner process.
+        end
+      end
+      monitor&.kill if monitor&.alive?
+    end
+
+    # Reaps the inner process and runs on_death (which stops the outer
+    # server) whenever it exits, so the daemon dies instead of serving
+    # without the lint engine behind it.
+    def monitor_inner(pid, on_death:)
+      Thread.new do
+        Process.wait(pid)
+        on_death.call
+      end
+    end
+
+    # Boots the inner native server and blocks until it answers
+    # /v2/check. Raises InnerDied when it dies during startup, and
+    # InnerTimeout when it never becomes ready (the child is killed and
+    # reaped first, so a failed boot leaks no process). Both messages quote
+    # the inner log's first line.
+    def spawn_inner(install:, port:, log_path:)
+      executable = install.executable!
+      begin
+        pid = Process.spawn(executable, "--port", port.to_s,
+          out: File::NULL, err: log_path)
+      rescue Errno::ENOENT
+        raise ServerError, "cannot exec #{executable.inspect}."
+      end
+      ready = false
+      died = false
+      deadline = Time.now + SimpleEnglish::LanguageTool::TIMEOUT_SECONDS
+      until ready || died || Time.now > deadline
+        # A process that dies instantly must not be polled for the full timeout.
+        # WNOHANG reaps it here, so nothing else may wait on this pid after.
+        died = !!Process.wait(pid, Process::WNOHANG)
+        break if died
+        begin
+          Net::HTTP.post_form(URI("http://localhost:#{port}/v2/check"),
+            {"language" => "en",
+             "enabledRules" => SimpleEnglish::LanguageTool.rule_ids.first,
+             "enabledOnly" => "true",
+             "text" => "a"})
+          ready = true
+        rescue SystemCallError
+          sleep 0.5
+        end
+      end
+      if died
+        raise InnerDied,
+          "lint engine exited during startup. " \
+          "First log line: #{first_log_line(log_path)}"
+      end
+      unless ready
+        kill_and_reap(pid)
+        raise InnerTimeout,
+          "lint engine did not start " \
+          "within #{SimpleEnglish::LanguageTool::TIMEOUT_SECONDS} seconds. " \
+          "First log line: #{first_log_line(log_path)}"
+      end
+      pid
+    end
+
+    def kill_and_reap(pid)
+      Process.kill("TERM", pid)
+      Process.wait(pid)
+    rescue SystemCallError
+    end
+
+    def first_log_line(path)
+      File.read(path).split("\n").first || "unknown"
+    rescue SystemCallError
+      "unknown"
+    end
+  end
+end

data/lib/simple_english/lint/annotated_text.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# LanguageTool AnnotatedText for code comments. Builds the annotation
+# JSON and maps LT match offsets back to file line and UTF-16 column.
+# Offsets are UTF-16 code units that count into the concatenation of
+# all text and markup strings. interpretAs does not count. Semantics
+# verified against a live LT 6.6 server on 2026-09-25.
+
+require_relative "extractor"
+require_relative "segment"
+require_relative "result"
+
+module SimpleEnglish
+  module AnnotatedText
+    # ASCII comment markers only (MARKER holds the set).
+    MARKER = /\A[\/#*;%-]+/
+    CLOSER = /\A.*?(\s*\*\/)\z/m
+
+    module_function
+
+    def build(source, spans)
+      segments = []
+      cursor = 0 # byte offset into source
+      emit = lambda do |text:, content:, file_char:, interpret_as: nil|
+        next if content.empty?
+        segments << Segment.new(text: text, content: content, file_char: file_char,
+          stream_start: segments.sum { |s| s.content.length }, interpret_as: interpret_as)
+      end
+      spans = spans.sort_by(&:start_byte)
+      spans.each do |span|
+        if cursor < span.start_byte
+          # Interior gaps break sentences between comments. Gaps with no
+          # checkable text before them (leading) change nothing.
+          emit.call(text: false, content: source.byteslice(cursor...span.start_byte),
+            file_char: char_index(source, cursor),
+            interpret_as: (segments.any? { |s| s.text }) ? "\n\n" : nil)
+        end
+        marker, body, closer = split(span.text)
+        file_char = char_index(source, span.start_byte)
+        emit.call(text: false, content: marker, file_char: file_char, interpret_as: " ")
+        emit.call(text: true, content: body, file_char: file_char + marker.length)
+        unless closer.empty?
+          emit.call(text: false, content: closer,
+            file_char: file_char + marker.length + body.length)
+        end
+        cursor = span.end_byte
+      end
+      emit.call(text: false, content: source.byteslice(cursor..),
+        file_char: char_index(source, cursor), interpret_as: nil)
+      Result.new(source: source, segments: segments,
+        stream: segments.map(&:content).join)
+    end
+
+    def data_json(result)
+      require "json"
+      JSON.generate("annotation" => result.segments.map do |segment|
+        if segment.text
+          {"text" => segment.content}
+        else
+          entry = {"markup" => segment.content}
+          entry["interpretAs"] = segment.interpret_as if segment.interpret_as
+          entry
+        end
+      end)
+    end
+
+    # -> [line, column], both 1-based. Column in UTF-16 code units.
+    def locate(result, utf16_offset)
+      char = utf16_to_char(result.stream, utf16_offset)
+      segment = result.segments.find do |s|
+        char >= s.stream_start && char < s.stream_start + s.content.length
+      end || result.segments.last
+      file_char = segment.file_char + (char - segment.stream_start)
+      starts = line_starts(result.source)
+      line = starts.rindex { |start| start <= file_char } + 1
+      [line, utf16_column(result.source, starts[line - 1], file_char)]
+    end
+
+    def split(comment)
+      marker = comment[MARKER] || ""
+      body = comment[marker.length..] || comment
+      closer = body[CLOSER] || ""
+      body = body[0, body.length - closer.length] unless closer.empty?
+      [marker, body, closer]
+    end
+
+    def char_index(source, byte)
+      # ponytail: O(filesize) per call. If large repos make this
+      # measurable, index byte->char once.
+      source.byteslice(0...byte).length
+    end
+
+    def line_starts(source)
+      starts = [0]
+      source.chars.each_with_index { |c, i| starts << i + 1 if c == "\n" }
+      starts
+    end
+
+    def utf16_to_char(stream, offset)
+      units = 0
+      stream.each_char.with_index do |char, index|
+        return index if units >= offset
+        units += (char.ord > 0xFFFF) ? 2 : 1
+      end
+      stream.length
+    end
+
+    def utf16_column(source, from, to)
+      units = 1
+      source[from...to].each_char { |c| units += (c.ord > 0xFFFF) ? 2 : 1 }
+      units
+    end
+
+    private_class_method :split, :char_index, :line_starts,
+      :utf16_to_char, :utf16_column
+  end
+end

data/lib/simple_english/lint/counts.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Counting rules: sentence and paragraph length. Pure text analysis.
+
+module SimpleEnglish
+  module Counts
+    PROCEDURAL_WORD_LIMIT = 20
+    DESCRIPTIVE_WORD_LIMIT = 25
+    PARAGRAPH_SENTENCE_LIMIT = 6
+
+    module_function
+
+    # Takes Markdown-stripped text, returns findings for long
+    # sentences and long paragraphs.
+    def check(text)
+      Markdown.paragraphs(text).flat_map { |paragraph| findings_for(paragraph) }
+    end
+
+    def findings_for(paragraph)
+      sentences = Markdown.sentences_of(paragraph.lines.join(" "))
+      limit = paragraph.procedural ? PROCEDURAL_WORD_LIMIT : DESCRIPTIVE_WORD_LIMIT
+
+      findings = sentences
+        .select { |sentence| sentence.split.size > limit }
+        .map do |_sentence|
+        Finding.new(line: paragraph.start_line, column: nil, rule: "SE_SENTENCE_TOO_LONG",
+          message: "Sentence has more than #{limit} words. Split it.")
+      end
+
+      if !paragraph.procedural && sentences.size > PARAGRAPH_SENTENCE_LIMIT
+        findings << Finding.new(line: paragraph.start_line, column: nil, rule: "SE_PARAGRAPH_TOO_LONG",
+          message: "Paragraph has more than #{PARAGRAPH_SENTENCE_LIMIT} " \
+                   "sentences. Give one topic six sentences at most.")
+      end
+      findings
+    end
+
+    private_class_method :findings_for
+  end
+end

data/lib/simple_english/lint/extractor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Tree-sitter comment extraction. One walk, no per-language code:
+# every grammar marks comments with a kind ending in "comment".
+
+require_relative "span"
+
+module SimpleEnglish
+  module Extractor
+    EXTENSION_LANGUAGES = {
+      ".py" => "python",
+      ".rb" => "ruby",
+      ".js" => "javascript",
+      ".mjs" => "javascript",
+      ".ts" => "typescript",
+      ".yaml" => "yaml",
+      ".yml" => "yaml",
+      ".go" => "go",
+      ".rs" => "rust",
+      ".java" => "java",
+      ".sh" => "bash",
+      ".kt" => "kotlin",
+      ".cs" => "csharp",
+      ".cpp" => "cpp",
+      ".cc" => "cpp",
+      ".cxx" => "cpp",
+      ".hpp" => "cpp",
+      ".h" => "cpp"
+    }.freeze
+
+    module_function
+
+    # nil for files we do not lint.
+    def language_for(path)
+      EXTENSION_LANGUAGES[File.extname(path)]
+    end
+
+    def comment_spans(source, language)
+      require "tree_sitter_language_pack"
+      root = TreeSitterLanguagePack.get_parser(language).parse(source).root_node
+      spans = []
+      stack = [root]
+      until stack.empty?
+        node = stack.pop
+        if comment?(node)
+          spans << Span.new(text: source.byteslice(node.start_byte...node.end_byte),
+            start_byte: node.start_byte, end_byte: node.end_byte)
+        end
+        (node.child_count - 1).downto(0) { |i| stack.push(node.child(i)) }
+      end
+      spans.sort_by!(&:start_byte)
+    end
+
+    def comment?(node)
+      node.kind.end_with?("comment") && !node.kind.start_with?("non")
+    end
+
+    private_class_method :comment?
+  end
+end

data/lib/simple_english/lint/finding.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# One lint result. Positions are 1-based. The end position is exclusive.
+# Counting findings have no columns or end positions. Findings from an older
+# daemon can have a start column without an end position.
+
+module SimpleEnglish
+  Finding = Struct.new(:line, :column, :end_line, :end_column, :rule, :message) do
+    # One finding as a text line: `path:line:col-end: [rule] message`.
+    # The CLI text output, the MCP tool, and the hook feedback all share
+    # this format. Keep them in step by rendering through this method.
+    def to_line(path)
+      location = "#{path}:#{line}"
+      if column
+        location += ":#{column}"
+        if end_line && end_column
+          finish = (end_line == line) ? end_column : "#{end_line}:#{end_column}"
+          location += "-#{finish}"
+        end
+      end
+      "#{location}: [#{rule}] #{message}"
+    end
+  end
+end

data/lib/simple_english/lint/lint_plan.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# One decision, two callers: the CLI (SimpleEnglish.lint_file) and
+# the daemon (Engine.lint) must agree on what kind of lint an input
+# is. The CLI decides to skip comment-free files without a boot.
+# The daemon decides again on its side of the wire. Both call this
+# module, so the two tiers cannot drift.
+
+module SimpleEnglish
+  module LintPlan
+    module_function
+
+    # Returns :prose when there is no language (the Markdown
+    # pipeline), nil for a comment-free code file (nothing to lint:
+    # no boot, no POST), or the comment spans for a code file.
+    def call(text, language)
+      return :prose unless language
+      spans = SimpleEnglish::Extractor.comment_spans(text, language)
+      spans.empty? ? nil : spans
+    end
+  end
+end

data/lib/simple_english/lint/markdown.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "paragraph"
+
+# Markdown stripping and paragraph splitting. Block structure comes
+# from the tree-sitter Markdown grammar shipped with the pack the
+# extractor already uses. Inline fixes stay regular expressions.
+# Stripping keeps the line count identical to the source.
+
+module SimpleEnglish
+  module Markdown
+    # A terminator ends a sentence only before whitespace or at the
+    # end of the text, so periods inside URLs and file names do not
+    # split sentences.
+    SENTENCE_END = /(?<=[.!?])(?:\s+|$)/
+    # Non-prose blocks: their lines never reach the counting rules or
+    # LanguageTool.
+    BLANKED_BLOCKS = %w[fenced_code_block indented_code_block thematic_break].freeze
+    UNDERLINE = /\Asetext_h\d_underline\z/
+
+    module_function
+
+    # Blank out code and other non-prose blocks and neutralize inline
+    # code and heading markers. Line count and UTF-16 widths stay identical
+    # to the source so LanguageTool offsets remain source positions.
+    def strip(text)
+      blank = blank_rows(text).to_h { |row| [row, true] }
+      text.lines.each_with_index.map do |line, row|
+        ending = if line.end_with?("\r\n")
+          "\r\n"
+        elsif line.end_with?("\n")
+          "\n"
+        else
+          ""
+        end
+        body = line.delete_suffix(ending)
+        (blank[row] ? spaces_for(body) : strip_line(body)) + ending
+      end.join
+    end
+
+    def strip_line(line)
+      # Width-preserving replacements keep LanguageTool positions aligned
+      # with the source.
+      line
+        .gsub(/`[^`]*`/) { |code| "X" * utf16_length(code) }
+        .sub(/\A\#{1,6} /) { |marker| " " * marker.length }
+    end
+
+    def spaces_for(text)
+      " " * utf16_length(text)
+    end
+
+    def utf16_length(text)
+      text.each_char.sum { |char| (char.ord > 0xFFFF) ? 2 : 1 }
+    end
+
+    # A vertical list is not one paragraph: each list item is its own.
+    # Paragraph boundaries come from the tree-sitter Markdown grammar,
+    # so lazy continuations and interrupted lists match the spec
+    # instead of line-shape heuristics.
+    def paragraphs(text)
+      root = parse(text)
+      nodes = []
+      each_node(root) { |node| nodes << node if node.kind == "paragraph" }
+      nodes.sort_by!(&:start_byte)
+      nodes.filter_map do |node|
+        body = text.byteslice(node.start_byte, node.end_byte - node.start_byte)
+        lines = body.lines.map(&:strip).reject(&:empty?)
+        next if lines.empty?
+        Paragraph.new(lines: lines, start_line: node.start_position.row + 1,
+          procedural: inside_list_item?(node))
+      end
+    end
+
+    def sentences_of(paragraph_body)
+      paragraph_body.split(SENTENCE_END).map(&:strip).reject(&:empty?)
+    end
+
+    # The rows (0-based) a node fully occupies. Tree-sitter end
+    # positions are exclusive. A node ending at column 0 does not
+    # cover that row.
+    def node_rows(node)
+      last = node.end_position.column.zero? ? node.end_position.row - 1 : node.end_position.row
+      (node.start_position.row..last)
+    end
+
+    def blank_rows(text)
+      rows = []
+      each_node(parse(text)) do |node|
+        next if node.kind == "paragraph" # prose, not a block to blank
+        rows.concat(node_rows(node).to_a) if
+          BLANKED_BLOCKS.include?(node.kind) || UNDERLINE.match?(node.kind)
+      end
+      rows
+    end
+
+    def each_node(root)
+      stack = [root]
+      until stack.empty?
+        node = stack.pop
+        yield node
+        # No paragraphs live inside code blocks. Skip their subtrees.
+        next if BLANKED_BLOCKS.include?(node.kind)
+        node.child_count.times { |i| stack.push(node.child(i)) }
+      end
+    end
+
+    def inside_list_item?(node)
+      return false unless node.parent
+      node.parent.kind == "list_item" || inside_list_item?(node.parent)
+    end
+
+    def parse(text)
+      require "tree_sitter_language_pack"
+      TreeSitterLanguagePack.get_parser("markdown").parse(text).root_node
+    end
+
+    private_class_method :strip_line, :spaces_for, :utf16_length, :node_rows,
+      :blank_rows, :each_node, :inside_list_item?, :parse
+  end
+end

data/lib/simple_english/lint/paragraph.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SimpleEnglish
+  module Markdown
+    # A paragraph of prose: its lines, the first line's number in the
+    # source, and whether it starts with a list item (procedural text
+    # gets a tighter sentence limit).
+    Paragraph = Struct.new(:lines, :start_line, :procedural)
+  end
+end