dopairb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7e71c4e0e91c35575f8ac0ebc641873bc4fc5af8dfc78b3ab4b17aa2b9ab3057
+  data.tar.gz: df276b5e5997edf7eaf128f022c6475a39b8db2949317e64db718bc8c91bf15a
+SHA512:
+  metadata.gz: 1fed2568ae4137a3da8d88c4d7ce74cf79ec6fba2f82d5d823a5cae1e063f91d35363910f7b68e3e154de0491b249e6125c1eea72c45fd6d399ed0b86244c055
+  data.tar.gz: 7a117f3e7a8ae10726a56b3469c8580fe7e68e0a1cad2a4c1b145ea8e480ff35d1a90ccd14e37a249e3078da1d095998b1c55c0e14ddd56ed1ae3e3917493387

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Koichi Sasada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# dopairb
+
+An interactive Ruby shell that answers every keystroke, evaluation, result and exception with loud terminal effects.
+It is built as an IRB extension. The design spec is [spec.md](spec.md) (in Japanese).
+
+```
+dopairb(main):001> (1..100).sum                     COMBO 00  SCORE 33  [⣿⣿⣀⣀⣀⣀⣀⣀] x1.5
+                    ⠂⠌⠟⠃        <- sparks, afterglow and HUD on every keystroke
+
+        █████ ███ ████   ████ █████    █   █ ███ █████ █
+        █      █  █   █ █       █      █   █  █    █   █     <- big moments: drop, impact, shockwave, fireworks
+        ████   █  ████   ███    █      █████  █    █   █
+✦ FIRST HIT! ✦  +252                                          <- optional one-line badge left behind
+=> 5050                                                        <- IRB's normal result output, untouched
+```
+
+## Install
+
+dopairb is not on rubygems.org yet. Install it from the repository:
+
+```console
+$ git clone https://github.com/ko1/dopairb
+$ cd dopairb
+$ gem build dopairb.gemspec && gem install ./dopairb-*.gem
+```
+
+To try it without installing, run `ruby exe/dopairb` in the checkout.
+
+## Usage
+
+```console
+$ dopairb                 # start it (IRB options are passed through)
+$ dopairb --calm          # quieter: low intensity, no flash, shorter effects
+$ dopairb --max           # everything at maximum; the biggest moments go full screen
+$ dopairb --party         # max + full-screen flash + bell
+$ dopairb --no-flash      # suppress flashing, available from the very first start
+$ DOPAIRB="intensity=low,flash=off" dopairb
+```
+
+To enable it in your regular `irb`, add this to `~/.irbrc`:
+
+```ruby
+require "dopairb"
+Dopairb.enable            # also e.g. Dopairb.enable(flash: :off, intensity: :low)
+```
+
+Inside a session, the `dopa` command changes settings:
+
+```
+dopa                  show settings and session stats
+dopa off|low|normal|max
+dopa calm / dopa party
+dopa demo             play every effect once (does not change your score)
+dopa flash=off duration=0.5 ...
+```
+
+### Settings
+
+| Setting | Values | Default | Meaning |
+| --- | --- | --- | --- |
+| `intensity` | off / low / normal / max | normal | Overall amount. `off` behaves exactly like plain IRB |
+| `motion` | on / off | on | `off` disables animation (badges only) |
+| `flash` | off / soft / full | soft | `soft` flashes only the effect area, `full` inverts the whole screen |
+| `sound` | on / off | off | Terminal bell on big moments |
+| `hud` | on / off | on | COMBO / SCORE / CHARGE on the right of the prompt line |
+| `duration` | 0.1–5 | 1.0 | Length multiplier for every effect |
+| `color` | auto / truecolor / 256 / 16 / none | auto | `none` when `NO_COLOR` is set |
+| `trail` | none / big / all | big | Which effects leave a one-line badge |
+| `charge` | 0–0.3 s | 0.12 | Wind-up before a fast result lands; 0 disables it |
+| `intro` | on / off | on | Title animation at startup |
+| `keys` | on / off | on | Per-keystroke effects |
+
+## Effects
+
+Effects come in four strengths: **small** (every key), **medium** (syntactic moments), **large** (evaluation finished) and **huge** (records and comebacks).
+When several fire at once, only the biggest plays. The smaller ones are folded into its subtitle rather than queued.
+
+| Moment | Effect |
+| --- | --- |
+| Typing | A spark trail right of the cursor, a brief glow on the typed character, embers falling below, a x1.0–x3.0 multiplier |
+| Resuming after a pause | Reignites with `CHARGE!` |
+| Backspace / Delete | The deleted character shatters and falls. The next keystroke shows `RECOVERY` |
+| Cursor movement | A light streak in the direction of travel |
+| Closing a bracket | The matching pair pulses, `NICE!` |
+| Closing a string or block | The range is highlighted, `end` shows `SEALED!` |
+| Accepting a completion | A light sweeps across the completed part, `<< LOCK ON` |
+| History recall | The line appears behind a scanline, `<< REWIND` |
+| Continuing a multi-line input | `CHARGE LV2`… |
+| Paste | One `PASTE x120` popup, no per-character effects |
+| Enter | A hot band sweeps across the input line ("EXECUTE"). Evaluations longer than 0.25 s show `CHARGING`, and after 3 s a calm elapsed-time readout |
+| Ordinary value | A comet flies from `=>` and lands, `+SCORE` `COMBO n` |
+| `nil` | A swing and a miss (`~~~`) and a puff of smoke |
+| `true` / `false` | A `YES!` / `NO!` stamp slams down |
+| Big numbers (≥10,000) | Giant digits count up, then a shockwave |
+| Long String / Array / Hash | Characters pour in / elements pop into place one by one |
+| `def` / `class` / `module` | Unlocks like `NEW ABILITY` |
+| 20+ lines of stdout | `OUTPUT RAIN` digital rain |
+| SyntaxError | The input line shakes and cracks, `SYNTAX BREAK`, with the error position |
+| NameError | A spotlight on that name in your input, `UNKNOWN SYMBOL` |
+| NoMethodError | The link between receiver and method snaps |
+| TypeError / ArgumentError | The two sides collide and explode (`TYPE CLASH` / `ARGUMENT CLASH`) |
+| Other exceptions | A red flash and a glitching `FAILED` |
+| Ctrl-C | The stored charge scatters, `INTERRUPTED` |
+| First eval / COMBO 5, 10, 25… / eval count 10, 50, 100… | `FIRST HIT!` / `COMBO 10!` / `100 EVALS` |
+| Numeric record (more than doubled) | `NEW RECORD` |
+| Success right after an error | `FIXED!` (after one error) / `COMEBACK!` (after a streak), both huge |
+| Exit | A result screen that counts up, left behind as a plain table |
+
+Error effects name the kind of error. They never make fun of the failure.
+
+## Readable, never broken
+
+- IRB evaluates and prints as usual. `=> value`, exception messages and backtraces come from IRB itself.
+  Effects are drawn in a temporary area and cleared. Only your input, the program's output and the result (plus an optional one-line badge) stay in the scrollback.
+- dopairb never calls your `#inspect` / `#to_s` for its effects. It classifies values only with `Module#===` and `bind_call` on built-in methods.
+- When your program writes to stdout or stderr during an evaluation, the waiting display and any effect get out of the way immediately. While a `system` / `spawn` / `IO.popen` child might write straight to the terminal, nothing is decorated.
+- Pressing a key during an effect ends it at once, and the key goes to Reline as usual. Per-keystroke effects pause while you paste.
+- Non-interactive runs (pipes, redirects), `TERM=dumb` and `intensity=off` emit no control sequences at all. `NO_COLOR` emits no color codes.
+- On narrow terminals, big-font banners fall back to spaced-out one-line text, then to badges only. On terminals where East Asian Ambiguous characters are two columns wide, box-drawing and block characters are replaced with ASCII or braille.
+- An exception inside an effect never reaches the REPL. Set `DOPAIRB_DEBUG=path` to log it.
+
+## Implementation
+
+dopairb extends IRB and has no evaluation engine of its own. All dependencies on IRB and Reline internals live in two files.
+
+- `lib/dopairb/reline_adapter.rb` (Reline 0.5–0.7, tested with 0.6.3)
+  - Public API: `Reline.add_dialog_proc` (three dialogs: HUD, spark trail, effect strip) and `output_modifier_proc` (glow on the input).
+  - Internals:
+    - `LineEditor#input_key`: before/after comparison of each key.
+    - `#handle_signal`: Reline calls it every 10 ms while waiting for input, so it serves as the animation tick.
+    - `#render`.
+    - `#render_finished`: records how the submitted input looks on screen.
+    - `Core#readmultiline`.
+- `lib/dopairb/irb_adapter.rb` (IRB 1.14–1.x, tested with 1.18.0)
+  - Public API: `IRB::Command.register(:dopa)` and `IRB.conf[:AT_EXIT]`.
+  - Internals: `IRB::Context#evaluate` (around each statement) and `IRB::WorkSpace#filter_backtrace` (hides dopairb's own frames).
+
+The rest is terminal-independent logic:
+
+- `Game`: COMBO / CHARGE / SCORE.
+- `Probe`: safe classification of values and exceptions.
+- `InputFx`: per-keystroke effects.
+- `Director` and the scenes in `scenes/`.
+- `Canvas`: a cell grid with a braille sub-pixel layer.
+- `Stage`: borrows a few rows at the cursor, draws, and restores the input line exactly.
+
+### Open questions in the spec (§11) and what was decided
+
+- The HUD is not pinned to the top of the screen. It sits at the right end of the prompt line while typing and disappears when the input is submitted.
+- Output printed during evaluation (`puts` etc.) is not decorated. Its lines are only counted, to trigger `OUTPUT RAIN`.
+- Scores live for the session only and are not saved.
+- Effects use Unicode. Any glyph that is not one column wide is swapped for ASCII or braille at runtime.
+- Start it with the `dopairb` command, or call `Dopairb.enable` in `.irbrc`.
+- IRB sessions entered via `binding.irb` get the same Context hook. The result screen appears only when the outermost session ends.
+
+## Performance
+
+These are rough numbers from a local machine, not a formal benchmark.
+Processing one key (`LineEditor#update` + `render`) takes about 3 ms in plain IRB and about 5.6 ms in dopairb.
+With keys typed 30 ms apart, both follow the input within 1 ms.
+While an effect is running, the screen is redrawn at up to 30 fps, about 1 ms per frame.
+
+## Development
+
+```console
+$ bundle exec rake test     # unit tests + every scene x width x color depth + PTY integration tests
+```
+
+The integration tests (`test/test_integration.rb`) start dopairb on a pseudo terminal. They rebuild the screen with a small VT100 model (`test/support/vt.rb`) and check the acceptance criteria of spec §10:
+
+- results and error messages remain as plain text
+- fast typing and pastes do not change the input
+- Ctrl-C works
+- narrow terminals work
+- `NO_COLOR` emits no color codes
+- non-interactive runs contain no control sequences
+- `intensity=off` behaves as plain IRB
+
+They require `setsid`.
+
+## Known limitations
+
+- Output that does not come from a child process (a C extension writing to fd 1 directly, `$stdout.reopen`, …) cannot be detected and may mix with the waiting display during an evaluation.
+- When a multi-line input grows at the bottom of the screen, the effect strip below the input disappears (the HUD and spark trail remain). The strip is also hidden while completion candidates are shown.
+- When IRB shows a long result in a pager (`less`), the effect finishes before the pager starts.
+- If the terminal is resized in the middle of an effect, the rest of that effect may be garbled. The next effect uses the new width.
+
+## License
+
+MIT

data/exe/dopairb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/dopairb/cli"
+
+Dopairb::CLI.start(ARGV)

data/lib/dopairb/canvas.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # A w x h grid of cells with an optional braille sub-pixel layer
+  # (2x4 dots per cell). Rendered to SGR-colored strings, one per row.
+  class Canvas
+    BRAILLE = [[0x01, 0x08], [0x02, 0x10], [0x04, 0x20], [0x40, 0x80]].freeze
+    CONT = :cont
+
+    attr_reader :w, :h
+
+    def initialize(w, h)
+      @w = w
+      @h = h
+      @ch = Array.new(h) { Array.new(w) }
+      @fg = Array.new(h) { Array.new(w) }
+      @bg = Array.new(h) { Array.new(w) }
+      @bold = Array.new(h) { Array.new(w, false) }
+      @dots = Array.new(h) { Array.new(w, 0) }
+      @dotc = Array.new(h) { Array.new(w) }
+    end
+
+    def put(x, y, str, fg = nil, bg: nil, bold: false)
+      x = x.round
+      y = y.round
+      return x if y < 0 || y >= @h
+      str.each_char do |c|
+        cw = c.ord < 0x80 ? 1 : Term.char_width(c)
+        if cw <= 0
+          next
+        elsif cw == 2
+          if x >= 0 && x + 1 < @w
+            set(x, y, c, fg, bg, bold)
+            set(x + 1, y, CONT, fg, bg, bold)
+          end
+        elsif x >= 0 && x < @w
+          set(x, y, c, fg, bg, bold)
+        end
+        x += cw
+      end
+      x
+    end
+
+    def char_at(x, y)
+      return nil unless x >= 0 && y >= 0 && x < @w && y < @h
+      @ch[y][x]
+    end
+
+    def put_center(y, str, fg = nil, bg: nil, bold: false)
+      put((@w - Term.str_width(str)) / 2, y, str, fg, bg: bg, bold: bold)
+    end
+
+    def bg(x, y, color)
+      x = x.round
+      y = y.round
+      return unless x >= 0 && y >= 0 && x < @w && y < @h
+      @bg[y][x] = color
+    end
+
+    def fill_bg(color, x0 = 0, y0 = 0, w = @w, h = @h)
+      (y0...(y0 + h)).each do |y|
+        next if y < 0 || y >= @h
+        (x0...(x0 + w)).each do |x|
+          @bg[y][x] = color if x >= 0 && x < @w
+        end
+      end
+    end
+
+    # Blend the existing background towards color by k (0..1). Unset bg is black.
+    def tint_bg(color, k, x0 = 0, y0 = 0, w = @w, h = @h)
+      (y0...(y0 + h)).each do |y|
+        next if y < 0 || y >= @h
+        (x0...(x0 + w)).each do |x|
+          next if x < 0 || x >= @w
+          @bg[y][x] = Color.mix(@bg[y][x] || [0, 0, 0], color, k)
+        end
+      end
+    end
+
+    # Sub-pixel dot; px in 0...(w*2), py in 0...(h*4)
+    def dot(px, py, color)
+      px = px.floor
+      py = py.floor
+      return if px < 0 || py < 0
+      x = px >> 1
+      y = py >> 2
+      return if x >= @w || y >= @h
+      @dots[y][x] |= BRAILLE[py & 3][px & 1]
+      @dotc[y][x] = color
+    end
+
+    def line(x0, y0, x1, y1, color)
+      steps = [((x1 - x0) * 2).abs, ((y1 - y0) * 4).abs, 1].max.ceil
+      (0..steps).each do |i|
+        t = i.fdiv(steps)
+        dot((x0 + (x1 - x0) * t) * 2, (y0 + (y1 - y0) * t) * 4, color)
+      end
+    end
+
+    # Ellipse in cell units; ry is visually halved by the cell aspect.
+    def ring(cx, cy, r, color, density: 1.0)
+      return if r <= 0
+      n = [(r * 12 * density).ceil, 8].max
+      n.times do |i|
+        a = i * 2 * Math::PI / n
+        dot((cx + Math.cos(a) * r) * 2, (cy + Math.sin(a) * r * 0.5) * 4, color)
+      end
+    end
+
+    def render(depth, shake: 0)
+      Array.new(@h) { |y| render_row(y, depth, shake) }
+    end
+
+    private
+
+    def set(x, y, c, fg, bg, bold)
+      @ch[y][x] = c
+      @fg[y][x] = fg
+      @bg[y][x] = bg if bg
+      @bold[y][x] = bold
+    end
+
+    def render_row(y, depth, shake)
+      chs = @ch[y]
+      last = @w - 1
+      last -= 1 while last >= 0 && chs[last].nil? && @dots[y][last] == 0 && @bg[y][last].nil?
+      out = +""
+      cur = nil
+      if shake > 0
+        out << (" " * shake)
+      end
+      start = shake < 0 ? -shake : 0
+      limit = shake > 0 ? [last, @w - 1 - shake].min : last
+      x = start
+      while x <= limit
+        c = chs[x]
+        if c == CONT
+          x += 1
+          next
+        end
+        fg = @fg[y][x]
+        bold = @bold[y][x]
+        if c.nil?
+          if @dots[y][x] != 0
+            c = Term.utf8? ? (0x2800 + @dots[y][x]).chr(Encoding::UTF_8) : "."
+            fg = @dotc[y][x]
+            bold = false
+          else
+            c = " "
+          end
+        end
+        style = [fg, @bg[y][x], bold]
+        if style != cur
+          out << (depth == :none && !bold && @bg[y][x].nil? ? "\e[0m" : Color.sgr(fg, @bg[y][x], bold, depth))
+          cur = style
+        end
+        out << c
+        x += 1
+      end
+      out << "\e[0m" if cur
+      out
+    end
+  end
+end

data/lib/dopairb/charge_line.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # Shown on the line below the input while an evaluation keeps running:
+  # an energetic charge at first, then a calm elapsed-time readout.
+  class ChargeLine
+    DELAY = 0.25
+    CALM_AFTER = 3.0
+
+    attr_reader :owner
+
+    def initialize(config, charge: 0.0)
+      @config = config
+      @charge = charge
+      @q = Thread::Queue.new
+      @drawn = false
+      @dead = false
+      @shown = false
+      @owner = nil
+    end
+
+    def shown? = @shown
+
+    def start
+      @t0 = now
+      @thread = Thread.new do
+        Thread.current.report_on_exception = false
+        @owner = Thread.current
+        run
+      end
+      self
+    end
+
+    def stop
+      @q << :stop
+      @thread&.join(0.5)
+      Term::LOCK.synchronize do
+        clear
+        @dead = true
+        Term.overlay = nil if Term.overlay.equal?(self)
+      end
+    end
+
+    # user output is coming (called under Term::LOCK)
+    def yield_to_output
+      clear
+      @dead = true
+      Term.overlay = nil if Term.overlay.equal?(self)
+    end
+
+    private
+
+    def run
+      return if @q.pop(timeout: DELAY)
+      Term::LOCK.synchronize do
+        return if @dead || OutputTap.output?
+        Term.overlay = self
+      end
+      depth = Term.depth(@config)
+      spin = %w[⣾ ⣽ ⣻ ⢿ ⡿ ⣟ ⣯ ⣷].map { |g| Term.glyph(g, "|") }
+      spin = %w[| / - \\] if spin.uniq.size == 1
+      i = 0
+      loop do
+        el = now - @t0
+        Term::LOCK.synchronize do
+          return if @dead
+          Term.out.write("\r\e[2K#{line(el, i, spin, depth)}\e[0m\r")
+          @drawn = true
+          @shown = true
+        end
+        i += 1
+        break if @q.pop(timeout: el < CALM_AFTER ? 1 / 15.0 : 0.5)
+      end
+    end
+
+    def line(el, i, spin, depth)
+      cols = Term.cols - 2
+      if el < CALM_AFTER || !@config.motion
+        k = (el - DELAY) / (CALM_AFTER - DELAY)
+        cells = [[cols - 30, 24].min, 4].max
+        filled = (cells * k.clamp(0, 1)).round
+        bar = +""
+        cells.times do |x|
+          on = x < filled
+          col = on ? Color.ramp(Color::FIRE, 0.5 - 0.4 * ((x - i) % 6) / 6.0) : [60, 60, 70]
+          bar << Color.sgr(col, nil, on, depth) << Term.glyph(on ? "⣿" : "⣀", on ? "#" : ".")
+        end
+        head = Color.sgr(Color.rainbow(el), nil, true, depth)
+        "#{head}#{spin[i % spin.size]} CHARGING\e[0m #{bar}\e[0m #{Color.sgr([255, 220, 150], nil, true, depth)}#{format('%.1fs', el)}"[0, cols * 30]
+      else
+        "#{Color.sgr([110, 130, 170], nil, false, depth)}#{spin[i % spin.size]} running #{clock(el)}  (Ctrl-C to interrupt)"
+      end
+    end
+
+    def clear
+      return unless @drawn
+      Term.out.write("\r\e[2K")
+      @drawn = false
+    end
+
+    def clock(el)
+      el < 60 ? format("%.1fs", el) : format("%dm%02ds", el / 60, el % 60)
+    end
+
+    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/dopairb/cli.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "../dopairb"
+
+module Dopairb
+  # `dopairb [dopairb options] [--] [irb options]`
+  module CLI
+    module_function
+
+    def parser(settings)
+      OptionParser.new do |o|
+        o.require_exact = true
+        o.banner = "Usage: dopairb [options] [-- irb options]"
+        o.separator ""
+        o.separator "IRB with fireworks. Every other option is handed to IRB."
+        o.separator ""
+        o.on("--intensity=LEVEL", Config::INTENSITIES.map(&:to_s), "off / low / normal (default) / max") { |v| settings << [:intensity, v] }
+        o.on("--calm", "low intensity, no flash, shorter effects") { settings.concat([[:intensity, :low], [:flash, :off], [:duration, 0.7]]) }
+        o.on("--max", "everything at maximum") { settings << [:intensity, :max] }
+        o.on("--party", "max + full-screen flash + bell") { settings.concat([[:intensity, :max], [:flash, :full], [:sound, true]]) }
+        o.on("--[no-]flash[=MODE]", "flash: off / soft (default) / full") { |v| settings << [:flash, v.nil? ? :soft : (v == false ? :off : v)] }
+        o.on("--[no-]motion", "animations (default on)") { |v| settings << [:motion, v] }
+        o.on("--[no-]sound", "terminal bell on big moments (default off)") { |v| settings << [:sound, v] }
+        o.on("--[no-]hud", "COMBO / SCORE next to the prompt (default on)") { |v| settings << [:hud, v] }
+        o.on("--[no-]keys", "per-keystroke effects (default on)") { |v| settings << [:keys, v] }
+        o.on("--[no-]intro", "title animation (default on)") { |v| settings << [:intro, v] }
+        o.on("--duration=X", Float, "effect length multiplier") { |v| settings << [:duration, v] }
+        o.on("--set=K=V,...", "any setting, same format as $DOPAIRB") { |v| settings << [:string, v] }
+        o.on("--version", "print version") do
+          puts "dopairb #{VERSION} (irb #{IRB::VERSION}, reline #{Reline::VERSION})"
+          exit
+        end
+        o.on("-h", "--help", "this help") do
+          puts o
+          puts
+          puts "Settings (also via DOPAIRB=\"key=value,...\" or `dopa key=value` inside the session):"
+          puts Config.new.describe
+          exit
+        end
+      end
+    end
+
+    def split_args(argv)
+      return [argv[0...argv.index("--")], argv[(argv.index("--") + 1)..]] if argv.include?("--")
+      argv.partition { |a| ours?(a) }
+    end
+
+    def ours?(arg)
+      return true if %w[-h --help --version].include?(arg)
+      return false unless arg.start_with?("--")
+      parser([]).parse([arg])
+      true
+    rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption
+      false
+    rescue OptionParser::ParseError
+      true
+    end
+
+    def start(argv = ARGV)
+      ours, irb_args = split_args(argv.dup)
+      settings = []
+      parser(settings).parse!(ours)
+      settings.each do |k, v|
+        k == :string ? Dopairb.config.apply_string(v) : Dopairb.config.set(k, v)
+      end
+      run_irb(irb_args)
+    rescue OptionParser::ParseError, ArgumentError => e
+      warn "dopairb: #{e.message}"
+      exit 2
+    end
+
+    def run_irb(irb_args)
+      STDOUT.sync = true
+      $0 = "dopairb"
+      IRB.setup(nil, argv: irb_args)
+      Dopairb.enable
+      IRB.conf[:PROMPT][:DOPAIRB] = {
+        PROMPT_I: "dopairb(%m):%03n> ",
+        PROMPT_S: "dopairb(%m):%03n%l ",
+        PROMPT_C: "dopairb(%m):%03n* ",
+        RETURN: "=> %s\n",
+      }
+      IRB.conf[:PROMPT_MODE] = :DOPAIRB if IRB.conf[:PROMPT_MODE] == :DEFAULT
+      irb = IRB::Irb.new
+      Dopairb.session.intro
+      irb.run(IRB.conf)
+    end
+  end
+end