letsdo 0.1.0 → 0.3.0

data/lib/letsdo/tui/session.rb

@@ -1,90 +1,31 @@
 # frozen_string_literal: true
 
+require_relative 'session/keys'
+require_relative 'session/view'
+
 module Letsdo
   module Tui
-    # The TUI controller: owns the terminal lifecycle, the background input
-    # thread and the repaint loop around an orchestrator run.
-    #
-    # Threading model (the orchestrator loop stays on the calling thread,
-    # exactly as in plain mode — Letsdo::PiRunner's signal design keeps
-    # working unchanged):
-    #   main thread    — the injected block (Letsdo::AgentLoop#run with its
-    #                    own signal traps): provider queries, agent runs,
-    #                    streamer writes into the log, metrics events;
-    #   input thread   — the SOLE repainter: polls keys (tty-reader),
-    #                    drains the log snapshot, tracks the metrics
-    #                    snapshot and repaints on keys, data, 1s timer
-    #                    ticks and SIGWINCH. Never touches the loop.
-    #
-    # Interactive actions (footer lists them):
-    #   ↑ / ↓ / PgUp / PgDn / Home / End — scroll; the view auto-follows
-    #     the newest line while at the bottom (tail -f semantics);
-    #   p — pause/resume: display freeze (PAUSED in the header, the log
-    #     keeps buffering, the view stays); keys still repaint;
-    #   r — immediate backlog re-query for the 'left' metric;
-    #   q / Ctrl-C — quit: exactly the signal-stop unwinding — Letsdo::Stopped
-    #     raised into the main thread terminates the pi child (PiRunner
-    #     rescue), stops the loop (AgentLoop rescue) and restores the
-    #     terminal from the ensure block; exit code 0.
-    #
-    # Signals: SIGWINCH sets a flag → the input thread re-queries the size
-    # and repaints (no corruption). SIGINT/SIGTERM keep working through the
-    # loop's own traps (main thread).
+    # The TUI controller: terminal lifecycle, background input thread, and
+    # the repaint loop around an orchestrator run.
     class Session
-      # 1s session-timer repaint interval.
+      include SessionKeys
+      include SessionView
+
       REPAINT_INTERVAL = 1.0
-      # Poll sleep when the display is frozen or nothing happened (avoids a
-      # busy loop while still repainting at the timer interval).
       IDLE_SLEEP = 0.01
-      # How long teardown waits for the input thread to finish its poll.
       INPUT_JOIN_TIMEOUT = 2.0
 
-      # @param name [String] agent name (header identity)
-      # @param handle [String] assignee handle (header identity)
-      # @param log [LogBuffer] the combined log the streamer writes into
-      # @param metrics [Metrics] the header metrics facade
-      # @param terminal [Terminal] the terminal wrapper
-      # @param input [Input] the key reader
-      # @param refresh [Proc, nil] callable → open task count (Integer) or
-      #        nil (backlog unreadable); 'r' uses it for an immediate
-      #        re-query
-      # @param wait_seconds [Numeric] retry interval for the waiting state
-      # @param clock [Proc] monotonic clock for tick timing (injectable)
-      def initialize(name:, handle:, log:, metrics:, terminal:, input:,
-                     refresh: nil, wait_seconds: 10.0, clock: nil)
-        @name = name
-        @handle = handle
-        @log = log
-        @metrics = metrics
-        @terminal = terminal
-        @input = input
-        @refresh = refresh
-        @wait_seconds = wait_seconds
-        @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
-        @offset = 0
-        @follow = true
-        @paused = false
-        @stop = false
-        @winch = false
-        @body_height = 1
-        @seen_version = 0
-        @input_thread = nil
+      def initialize(**opts)
+        assign_identity(opts)
+        assign_io(opts)
+        assign_controls(opts)
+        reset_view_state
       end
 
-      # Runs the TUI around the given orchestrator work.
-      #
-      # The block runs on the calling thread. On quit (q/Ctrl-C) or a stop
-      # signal Letsdo::Stopped unwinds it; the terminal is restored from
-      # the ensure block on every exit path.
-      #
-      # @yield the orchestrator run (e.g. Letsdo::AgentLoop#run)
-      # @return [Integer] the block's result, or 0 when stopped
       def run(&work)
         install_winch_handler
         @terminal.enter
-        start_input_thread
-        result = work.call
-        result
+        run_work(&work)
       rescue Letsdo::Stopped
         0
       ensure
@@ -93,124 +34,50 @@ module Letsdo
         restore_winch_handler
       end
 
-      private
-
-      # The input thread body: the only place that writes to the terminal.
-      def input_loop
+      def run_work(&work)
         with_raw_input do
-          repaint
-          @last_repaint = @clock.call
-          loop do
-            break if @stop
-
-            key = @input.next_key
-            handled = key ? handle_key(key) : false
-            winch = take_winch
-            handled = true if winch
-            now = @clock.call
-            tick = now - @last_repaint >= REPAINT_INTERVAL
-            new_data = @log.version != @seen_version
-            if handled || (!@paused && (tick || new_data))
-              repaint
-              @last_repaint = @clock.call
-            else
-              sleep(IDLE_SLEEP)
-            end
-          end
+          start_input_thread
+          work.call
         end
-      rescue StandardError
-        # The input thread must never die loudly into the middle of the
-        # screen, and a quiet exit still leaves the loop running (teardown
-        # joins it). Terminal state is restored by the ensure blocks.
-        nil
       end
 
-      def handle_key(key)
-        case key
-        when :up, :page_up
-          @offset -= key == :page_up ? page_step : 1
-          @follow = false
-          true
-        when :down, :page_down
-          @offset += key == :page_down ? page_step : 1
-          true # repaint decides re-sticking at the bottom
-        when :home
-          @offset = 0
-          @follow = false
-          true
-        when :end
-          @follow = true
-          true
-        when :p
-          @paused = !@paused
-          true
-        when :r
-          refresh
-          true
-        when :q, :ctrl_c
-          quit
-          false # leaving the session; no repaint needed
-        else
-          false
-        end
-      end
-
-      # Immediate backlog re-query: the provider is re-run on this thread
-      # (a subprocess call, thread-safe) and the count reaches the header
-      # snapshot.
-      def refresh
-        return unless @refresh
-
-        @metrics.provider_result(@refresh.call)
-      end
-
-      # Quit = the same unwinding as a stop signal: Letsdo::Stopped raised
-      # into the main thread (inside the orchestrator work) terminates the
-      # pi child and stops the loop; the ensure block restores the
-      # terminal. No-op after teardown already started.
-      def quit
-        return if @stop
+      private
 
-        Thread.main.raise(Letsdo::Stopped)
+      def assign_identity(opts)
+        @name = opts.fetch(:name)
+        @handle = opts.fetch(:handle)
+        @log = opts.fetch(:log)
+        @metrics = opts.fetch(:metrics)
       end
 
-      # Repaints the whole frame from the current state.
-      def repaint
-        lines, version = @log.lines
-        @seen_version = version
-        height, width = @terminal.size
-        @body_height = Renderer.body_height_for(height)
-        max_offset = Renderer.max_offset(lines, @body_height)
-        if @paused
-          @offset = [[@offset, max_offset].min, 0].max
-        elsif @follow
-          @offset = max_offset
-        else
-          @offset = [[@offset, max_offset].min, 0].max
-          @follow = true if @offset == max_offset
-        end
-        frame = Renderer.render(
-          metrics: @metrics.snapshot, lines: lines, width: width, height: height,
-          offset: @offset, follow: @follow, paused: @paused,
-          wait_seconds: @wait_seconds
-        )
-        @terminal.render(frame)
+      def assign_io(opts)
+        @terminal = opts.fetch(:terminal)
+        @input = opts.fetch(:input)
+        @refresh = opts[:refresh]
+        @wait_seconds = opts.fetch(:wait_seconds, 10.0)
+        @clock = opts[:clock] || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       end
 
-      # Page height for PgUp/PgDn.
-      def page_step
-        @body_height.positive? ? @body_height : 1
+      def assign_controls(opts)
+        @pause_gate = opts[:pause_gate]
+        @runner = opts[:runner]
       end
 
-      def take_winch
-        flag = @winch
+      def reset_view_state
+        @offset = 0
+        @follow = true
+        @paused = false
+        @stop = false
         @winch = false
-        flag
+        @body_height = 1
+        @seen_version = 0
+        @input_thread = nil
       end
 
-      # Raw keyboard mode for the whole input session (the tty-reader
-      # per-read raw wraps would leave the terminal echoing between polls);
-      # no-op for non-tty inputs (tests use a pipe).
+      # Enters raw mode on the keyboard for the duration of the block. Held
+      # by the main thread (not the killable input thread) so the terminal
+      # state is restored on every quit path — a killed input thread would
+      # leave the shared tty in raw mode and break the calling shell (TASK-83).
       def with_raw_input(&block)
         if @input.stdin.tty? && @input.stdin.respond_to?(:raw)
           @input.stdin.raw(&block)
@@ -220,13 +87,13 @@ module Letsdo
       end
 
       def install_winch_handler
-        Signal.trap("SIGWINCH") { @winch = true }
+        Signal.trap('SIGWINCH') { @winch = true }
       rescue ArgumentError
-        nil # no SIGWINCH on this platform — no resize repaints
+        nil
       end
 
       def restore_winch_handler
-        Signal.trap("SIGWINCH", "DEFAULT")
+        Signal.trap('SIGWINCH', 'DEFAULT')
       rescue ArgumentError
         nil
       end
@@ -250,4 +117,4 @@ module Letsdo
       end
     end
   end
-end
+end

data/lib/letsdo/tui/terminal.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "tty-cursor"
-
 module Letsdo
   module Tui
     # Thin wrapper over the terminal: alternate screen, cursor handling and
@@ -24,28 +22,40 @@ module Letsdo
       # @param size_provider [Proc] callable → [height, width]; defaults to
       #        TTY::Screen.size; injected in tests for deterministic size
       def initialize(stream:, size_provider: nil)
-        require "tty-screen" unless defined?(TTY::Screen)
+        require 'tty-screen' unless defined?(TTY::Screen)
 
         @stream = stream
         @size_provider = size_provider ||
-                         -> { size = TTY::Screen.size; [size[0] || 24, size[1] || 80] }
+                         lambda {
+                           size = TTY::Screen.size
+                           [size[0] || 24, size[1] || 80]
+                         }
       end
 
       # Enters the alternate screen and hides the cursor.
       def enter
-        write(ENTER_ALT_SCREEN + TTY::Cursor.hide)
+        write(ENTER_ALT_SCREEN + cursor.hide)
       end
 
       # Shows the cursor and leaves the alternate screen.
       def leave
-        write(TTY::Cursor.show + LEAVE_ALT_SCREEN)
+        write(cursor.show + LEAVE_ALT_SCREEN)
       end
 
       # Repaints the whole frame: cursor to the top left, then the frame.
       #
+      # Row separators are written as CRLF (\r\n), never bare LF. The TUI
+      # input thread holds stdin in io-console raw mode for the whole
+      # session, and raw mode clears OPOST on the shared tty — without it a
+      # bare \n no longer implies a carriage return, so every row after the
+      # first would start at the previous row's end column and the frame
+      # would wrap/scroll into the "blank activity pane" scramble (TASK-82).
+      # Explicit CRLF renders correctly both in raw mode and on terminals
+      # whose ONLCR already expands \n (a doubled CR is harmless).
+      #
       # @param frame [String] the rendered screen (see Letsdo::Tui::Renderer)
       def render(frame)
-        write(HOME + frame)
+        write(HOME + frame.gsub("\n", "\r\n"))
       end
 
       # The current terminal size.
@@ -58,10 +68,18 @@ module Letsdo
 
       private
 
+      # Loaded lazily (like tty-screen/tty-reader) so requiring letsdo on a
+      # clean Ruby loads no tty-* gems — only the interactive TTY path needs
+      # them (TASK-78).
+      def cursor
+        require 'tty-cursor' unless defined?(TTY::Cursor)
+        TTY::Cursor
+      end
+
       def write(text)
         @stream.write(text)
         @stream.flush
       end
     end
   end
-end
+end

data/lib/letsdo/tui.rb

@@ -16,9 +16,9 @@
 #   Letsdo::Tui::Input      - tty-reader key decoding (injectable)
 #   Letsdo::Tui::Session    - controller: terminal lifecycle + input thread
 
-require_relative "tui/log_buffer"
-require_relative "tui/metrics"
-require_relative "tui/renderer"
-require_relative "tui/terminal"
-require_relative "tui/input"
-require_relative "tui/session"
+require_relative 'tui/log_buffer'
+require_relative 'tui/metrics'
+require_relative 'tui/renderer'
+require_relative 'tui/terminal'
+require_relative 'tui/input'
+require_relative 'tui/session'

data/lib/letsdo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Letsdo
-  VERSION = "0.1.0"
-end
+  VERSION = '0.3.0'
+end

data/lib/letsdo/watcher.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'fiddle/import'
+
+module Letsdo
+  # OS file-change watcher for the backlog folder.
+  #
+  # On Linux it subscribes to inotify (via Fiddle, no external gem) and wakes
+  # as soon as a backlog entry changes; everywhere else it degrades to the
+  # same periodic polling a plain sleeper would do. Either way the wait is
+  # interruptible — a signal trap raising Letsdo::Stopped breaks the
+  # underlying IO.select — and an internal self-pipe lets #wake interrupt a
+  # blocked #wait from another thread.
+  class Watcher
+    # inotify event masks we subscribe to (Linux <sys/inotify.h>).
+    IN_ACCESS       = 0x00000001
+    IN_MODIFY       = 0x00000002
+    IN_ATTRIB       = 0x00000004
+    IN_CLOSE_WRITE  = 0x00000008
+    IN_CLOSE_NOWRITE = 0x00000010
+    IN_OPEN         = 0x00000020
+    IN_MOVED_FROM   = 0x00000040
+    IN_MOVED_TO     = 0x00000080
+    IN_CREATE       = 0x00000100
+    IN_DELETE       = 0x00000200
+    IN_DELETE_SELF  = 0x00000400
+    IN_MOVE_SELF    = 0x00000800
+
+    RELEVANT_MASK = IN_CREATE | IN_MODIFY | IN_CLOSE_WRITE | IN_DELETE |
+                    IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE_SELF | IN_MOVE_SELF
+
+    EXCLUDED_DIR = '.locks'
+
+    # @param path [String] the watched folder (its direct entries)
+    # @param poll_seconds [Float] fallback poll interval / select timeout
+    def initialize(path:, poll_seconds: 10.0)
+      @poll_seconds = poll_seconds
+      @wake_r, @wake_w = IO.pipe
+      @backend = build_backend(path)
+    end
+
+    # Blocks until a relevant backlog change, an explicit #wake, or the poll
+    # timeout. Irrelevant events (e.g. .locks churn) keep the wait going for
+    # the remainder of the timeout.
+    #
+    # @return [Symbol] :change, :wake, or :timeout
+    def wait(timeout = @poll_seconds)
+      deadline = monotonic + timeout
+      loop do
+        result = wait_once(deadline)
+        return result if result
+      end
+    end
+
+    # Interrupts a blocked #wait from another thread.
+    def wake
+      @wake_w.write_nonblock('.')
+    rescue IO::WaitWritable, Errno::EPIPE
+      nil
+    end
+
+    def close
+      @backend&.close
+      close_io(@wake_w)
+      close_io(@wake_r)
+    end
+
+    private
+
+    def wait_once(deadline)
+      remaining = deadline - monotonic
+      return :timeout if remaining <= 0
+
+      ready = IO.select(read_fds, nil, nil, remaining)
+      return :timeout if ready.nil?
+      return :wake if wake_ready?(ready)
+
+      @backend.relevant_event? ? :change : nil
+    end
+
+    def read_fds
+      fds = [@wake_r]
+      fds << @backend.io if @backend
+      fds
+    end
+
+    def wake_ready?(ready)
+      return false unless ready.first.include?(@wake_r)
+
+      drain_wake
+      true
+    end
+
+    def drain_wake
+      @wake_r.read_nonblock(4096)
+    rescue IO::WaitReadable, EOFError
+      nil
+    end
+
+    def build_backend(path)
+      InotifyBackend.new(path, RELEVANT_MASK)
+    rescue InotifyBackend::Unavailable, Fiddle::DLError
+      nil
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def close_io(io)
+      io.close unless io.nil? || io.closed?
+    rescue IOError
+      nil
+    end
+
+    # Linux inotify backend. Construction raises InotifyBackend::Unavailable
+    # when inotify is missing or the watch cannot be set up, so the watcher
+    # falls back to polling through its self-pipe timeout.
+    class InotifyBackend
+      # libc inotify bindings via Fiddle (no external gem).
+      module Lib
+        extend Fiddle::Importer
+        dlload Fiddle.dlopen(nil)
+        extern 'int inotify_init1(int)'
+        extern 'int inotify_add_watch(int, const char*, uint32_t)'
+      end
+
+      # Signals that inotify is unavailable and the watcher should fall back.
+      class Unavailable < StandardError; end
+
+      IN_CLOEXEC = 0x00080000
+      EVENT_HEADER_SIZE = 16
+
+      attr_reader :io
+
+      def initialize(path, mask)
+        fd = Lib.inotify_init1(IN_CLOEXEC)
+        guard(fd)
+        @io = IO.new(fd, 'r', autoclose: true)
+        guard(Lib.inotify_add_watch(fd, path, mask))
+      rescue Unavailable, Fiddle::DLError
+        @io&.close
+        raise Unavailable
+      end
+
+      # Drains pending events and reports whether any relevant (non-.locks)
+      # entry changed.
+      def relevant_event?
+        buffer = @io.read_nonblock(8192)
+        parse_relevant(buffer)
+      rescue IO::WaitReadable, EOFError
+        false
+      end
+
+      def close
+        @io&.close
+      rescue IOError
+        nil
+      end
+
+      private
+
+      def guard(value)
+        raise Unavailable if value.negative?
+      end
+
+      def parse_relevant(buffer)
+        offset = 0
+        relevant = false
+        while offset + EVENT_HEADER_SIZE <= buffer.bytesize
+          _wd, mask, _cookie, len = buffer.byteslice(offset, EVENT_HEADER_SIZE).unpack('L4')
+          name = buffer.byteslice(offset + EVENT_HEADER_SIZE, len).to_s.sub(/\0.*/m, '')
+          relevant ||= relevant_mask?(mask) && !excluded?(name)
+          offset += EVENT_HEADER_SIZE + len
+        end
+        relevant
+      end
+
+      def relevant_mask?(mask)
+        (mask & Watcher::RELEVANT_MASK) != 0
+      end
+
+      def excluded?(name)
+        name == Watcher::EXCLUDED_DIR || name.start_with?("#{Watcher::EXCLUDED_DIR}/")
+      end
+    end
+  end
+end

data/lib/letsdo.rb

@@ -3,28 +3,35 @@
 # The Letsdo package — a local agent worker for Backlog.md/markdown tasks.
 #
 # OOP structure:
-#   Letsdo::Errors           - error hierarchy (UnknownAgentError and others)
+#   Letsdo::Errors           - error hierarchy (Letsdo::Error and others)
 #   Letsdo::PromptStore      - access to agents/*.md prompts
+#   Letsdo::DefaultPrompt    - the built-in default prompt (fallback run, --init template)
 #   Letsdo::OutputStreamer   - where and how agent text and service lines are printed
 #   Letsdo::PiRunner         - running pi --mode json and parsing the event stream
-#   Letsdo::Agent            - a single agent run: prompt from agents/ + pi
+#   Letsdo::Agent            - a single agent run: prompt from agents/ or default + pi
+#   Letsdo::Capture          - interruption-safe child stdout/stderr capture
 #   Letsdo::BacklogTasks     - open tasks from the backlog CLI (the task provider)
 #   Letsdo::Loop             - generic orchestrator: tasks → runs → waiting
 #   Letsdo::AgentLoop        - letsdo wiring: provider + agent + signals + messages
+#   Letsdo::Control          - agent-control primitives (PauseGate)
 #   Letsdo::Tui              - the interactive TUI (LogBuffer, Metrics,
 #                              Renderer, Terminal, Input, Session)
 #   Letsdo::CLI              - command-line arguments, usage, exit code
 #
 # Entry point — bin/letsdo (a thin wrapper over Letsdo::CLI).
 
-require_relative "letsdo/version"
-require_relative "letsdo/errors"
-require_relative "letsdo/prompt_store"
-require_relative "letsdo/output_streamer"
-require_relative "letsdo/pi_runner"
-require_relative "letsdo/agent"
-require_relative "letsdo/backlog_tasks"
-require_relative "letsdo/loop"
-require_relative "letsdo/agent_loop"
-require_relative "letsdo/tui"
-require_relative "letsdo/cli"
+require_relative 'letsdo/version'
+require_relative 'letsdo/errors'
+require_relative 'letsdo/prompt_store'
+require_relative 'letsdo/default_prompt'
+require_relative 'letsdo/output_streamer'
+require_relative 'letsdo/pi_runner'
+require_relative 'letsdo/agent'
+require_relative 'letsdo/capture'
+require_relative 'letsdo/backlog_tasks'
+require_relative 'letsdo/loop'
+require_relative 'letsdo/watcher'
+require_relative 'letsdo/agent_loop'
+require_relative 'letsdo/control'
+require_relative 'letsdo/tui'
+require_relative 'letsdo/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: letsdo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sergei O. Udalov
@@ -65,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.77.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.77.0
 description: 'letsdo — a local agent worker for Backlog.md/markdown tasks. OOP structure:
   Letsdo::PromptStore (agents/), Letsdo::OutputStreamer and Letsdo::PiRunner (pi --mode
   json), Letsdo::Agent (one run), Letsdo::Loop (orchestrator loop), Letsdo::CLI. Minitest
@@ -82,12 +96,21 @@ files:
 - lib/letsdo.rb
 - lib/letsdo/agent.rb
 - lib/letsdo/agent_loop.rb
+- lib/letsdo/agent_loop/tasks.rb
 - lib/letsdo/backlog_tasks.rb
+- lib/letsdo/capture.rb
 - lib/letsdo/cli.rb
+- lib/letsdo/cli/init.rb
+- lib/letsdo/cli/launch.rb
+- lib/letsdo/control.rb
+- lib/letsdo/default_prompt.rb
 - lib/letsdo/errors.rb
 - lib/letsdo/loop.rb
 - lib/letsdo/output_streamer.rb
+- lib/letsdo/output_streamer/arg_summary.rb
 - lib/letsdo/pi_runner.rb
+- lib/letsdo/pi_runner/events.rb
+- lib/letsdo/pi_runner/process.rb
 - lib/letsdo/prompt_store.rb
 - lib/letsdo/tui.rb
 - lib/letsdo/tui/input.rb
@@ -95,12 +118,20 @@ files:
 - lib/letsdo/tui/metrics.rb
 - lib/letsdo/tui/renderer.rb
 - lib/letsdo/tui/session.rb
+- lib/letsdo/tui/session/keys.rb
+- lib/letsdo/tui/session/view.rb
 - lib/letsdo/tui/terminal.rb
 - lib/letsdo/version.rb
+- lib/letsdo/watcher.rb
+homepage: https://github.com/sergio-fry/letsdo
 licenses:
 - MIT
 metadata:
+  homepage_uri: https://github.com/sergio-fry/letsdo
+  source_code_uri: https://github.com/sergio-fry/letsdo
+  changelog_uri: https://github.com/sergio-fry/letsdo/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
 rdoc_options: []
 require_paths:
 - lib