dopairb 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbc57c42e0e25caed6e783bf761e9edda9822c1d853fa4d55c144ce6704a875e
-  data.tar.gz: a3d81e85abe05052cbbf99907162215b4d27796fd0ed14827d83190c0252672e
+  metadata.gz: afb5e40866c1cdf891ccf500611c568c91f693715f120e69822088e7bdcffdf3
+  data.tar.gz: 25b611a5ac21351f1f9adf5fd811cbc6c8422651dd7cab94dbb878d68d25930d
 SHA512:
-  metadata.gz: 9522cb64cb142280f6ed6070e0e92884206fb0a7eccd1d289202c64ed9cb28a2cbb14d291a686362ce5797654910dec25f91ab2383193e82782cbd9bcceb7943
-  data.tar.gz: 6cae99bcfcdcf7419a2e943fda49cbb97f8603a7e7a09d17f23bf5beb165b8ab85e6cea0f99c6d20f0daa6304dcb13341c5ef9f2781e635642003a4e6dd4f11f
+  metadata.gz: 46b1c5c6e4b4450e0297b21d70a24da9ad379603512de745e208837a57a79f7b004eed7c5a748261c78052b1bb1aa44c564595d599552d3471c5055d5182a871
+  data.tar.gz: 8979f157991d9e6451e7ceb8df3fc480a86ee39bd350f2afe363d5c87ccc187e62dc729eefab57deaf3aaa6f975aee6e37a6f948cd7f7353b3fef574ee09e406

data/README.md

@@ -3,9 +3,9 @@
 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).
 
-https://github.com/user-attachments/assets/b45e4a97-ffde-4fb2-be73-ef69d5c8af42
+https://github.com/user-attachments/assets/98b037e1-5a30-4abd-812d-233a60ab2de4
 
-A 70-second session with sound (`dopairb`, the defaults); also in [docs/dopairb-demo.mp4](docs/dopairb-demo.mp4). The scripts that recorded it are in [docs/recording](docs/recording).
+A 72-second promo with sound and English/Japanese subtitles: plain irb, then `dopa on`, the setup, and "Happy dopa Ruby!". The scripts that record dopairb sessions like this one are in [docs/recording](docs/recording).
 
 ```
 dopairb(main):001> (1..100).sum                     COMBO 00  SCORE 33  [⣿⣿⣀⣀⣀⣀⣀⣀] x1.5
@@ -45,13 +45,14 @@ To turn your regular `irb` into dopairb, add this to `~/.irbrc`:
 
 ```ruby
 begin
-  require "dopairb"
-  Dopairb.enable          # also e.g. Dopairb.enable(sound: :off, intensity: :normal)
+  require "dopairb"   # adds the `dopa` command; `dopa on` starts the show
+  Dopairb.enable      # ...or start with the show on (e.g. Dopairb.enable(sound: :off))
 rescue LoadError
   # a Ruby without dopairb keeps plain irb
 end
 ```
 
+With only the `require`, irb stays plain until you type `dopa on`.
 The title (and the loading screen on a cold start) plays right before the first prompt, as with the `dopairb` command.
 Sessions opened by `binding.irb` get the effects too; `Dopairb.enable(binding_irb: false)` keeps them plain.
 Settings for a single run (`dopairb` options and `$DOPAIRB`) win over the ones given to `Dopairb.enable` in `.irbrc`.
@@ -60,6 +61,7 @@ Inside a session, the `dopa` command changes settings:
 
 ```
 dopa                  show settings and session stats
+dopa on / dopa off    switch the show on (back to the last level) or off
 dopa off|low|normal|max
 dopa calm / dopa party
 dopa demo             play every effect once (does not change your score)
@@ -134,7 +136,10 @@ Error effects name the kind of error. They never make fun of the failure.
 
 Between sessions dopairb keeps a small profile: lifetime XP (the sum of your scores), level, best score, best combo, a day streak and the bonus art you have collected.
 Levels need powers of two: LV 2 at 512 XP, LV 3 at 1,024, LV 4 at 2,048, and so on.
-Each level-up and each jackpot unveils a masterpiece full screen, and now and then (about 1 success in 50) one simply drops: `ART DROP!`. There are 100 public-domain works to collect, from the Lascaux horses and Hokusai's *Great Wave* through Vermeer, Turner and van Gogh to Klimt, Kandinsky and Mondrian, all painted procedurally in half blocks (no image files ship with the gem). New ones come first; `dopa gallery` lists yours. (Spoilers: all 100 are in [docs/gallery.png](docs/gallery.png).)
+Each level-up and each jackpot unveils a masterpiece full screen, and now and then (about 1 success in 50) one simply drops: `ART DROP!`. There are 100 public-domain works to collect, from the Lascaux horses and Hokusai's *Great Wave* through Vermeer, Turner and van Gogh to Klimt, Kandinsky and Mondrian, all painted procedurally in half blocks (no image files ship with the gem). New ones come first; `dopa gallery` lists yours.
+
+![100 frames, five of them filled](docs/gallery-teaser.png)
+
 The startup title shows your level and day streak, and the finale shows `NEW BEST!` and an XP bar.
 
 The profile is `~/.local/state/dopairb/profile.json` (`$XDG_STATE_HOME` is honored). Set `DOPAIRB_PROFILE=path` to use another file, or `DOPAIRB_PROFILE=off` to keep nothing; levels are then not shown.
@@ -161,6 +166,37 @@ PowerShell takes a few hundred milliseconds to start, so with it only the result
 When no player is found, `sfx` falls back to the terminal bell on big moments.
 Sound plays on the machine that runs dopairb, so over ssh you will not hear it.
 
+## Claude Code (dopacc)
+
+The gem also ships `dopacc`, which puts the show on top of [Claude Code](https://claude.com/claude-code):
+
+https://github.com/user-attachments/assets/458acc90-72ba-4a81-a352-082cde2096d5
+
+```
+gem install dopairb
+dopacc install        # adds hooks + a status line to ~/.claude/settings.json
+```
+
+Then restart Claude Code. From then on:
+
+- Every successful tool call adds to the COMBO with a chime. At 10 and above it is FEVER (x2 score).
+- At COMBO 8, 16, 32, ... a full-screen `COMBO 16!` banner with fireworks takes over the screen for two seconds.
+- A tool call has a 1/64 chance of a `JACKPOT!!` (x16).
+- A failed tool call breaks the combo with a crack.
+- When Claude finishes a turn that used tools, a full-screen `MISSION COMPLETE!` shows the turn's tools, score, combo and best.
+- The status line shows `COMBO / SCORE / BEST` (an existing `statusLine` is left alone).
+
+```
+dopacc off / calm / on   # nothing / sounds only / everything (inside Claude Code: ! dopacc off)
+dopacc status
+dopacc demo              # ! dopacc demo inside Claude Code shows a banner right away
+dopacc uninstall
+```
+
+`dopacc install --project` writes to `./.claude/settings.local.json` instead. `DOPACC=off` in the environment silences it too.
+
+How it works: Claude Code owns the terminal and its hooks run without one. So a hook walks up the process tree to Claude Code's tty, draws the banner on it, and then has Claude Code repaint. With the fullscreen TUI (`"tui": "fullscreen"`), it draws over Claude Code's screen and makes it lay itself out again by narrowing the window by one column for a moment. With the classic TUI, it draws on the alternate screen and switches back. Progress is kept in `~/.local/state/dopairb/dopacc.json`. Hooks never fail: whatever happens, they exit 0 silently (`DOPACC_DEBUG=1` prints errors).
+
 ## Readable, never broken
 
 - IRB evaluates and prints as usual. `=> value`, exception messages and backtraces come from IRB itself.

data/exe/dopacc

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# dopacc: dopairb's show on top of Claude Code.
+require_relative "../lib/dopairb/claude_code"
+
+CC = Dopairb::ClaudeCode
+
+def settings_path(args)
+  if (a = args.find { |x| x.start_with?("--settings=") })
+    a.delete_prefix("--settings=")
+  elsif args.include?("--project")
+    File.join(Dir.pwd, ".claude", "settings.local.json")
+  else
+    File.join(ENV["CLAUDE_CONFIG_DIR"] || File.expand_path("~/.claude"), "settings.json")
+  end
+end
+
+USAGE = <<~TXT
+  Usage: dopacc COMMAND
+
+    install [--project] [--no-statusline]  add the hooks to Claude Code's settings
+                                           (~/.claude/settings.json, or ./.claude/settings.local.json)
+    uninstall [--project]                  remove them again
+    on | calm | off                        full show / sounds only / nothing
+    status                                 mode, combo and score
+    demo [TEXT]                            try the full-screen banner (run it as `! dopacc demo` in Claude Code)
+    hook                                   (called by Claude Code with the hook JSON on stdin)
+    statusline                             (called by Claude Code for the status line)
+TXT
+
+cmd, *args = ARGV
+case cmd
+when "hook"
+  # Never get in Claude Code's way: whatever happens, exit 0 quietly.
+  begin
+    plan = CC::Hook.run($stdin.read)
+    if ENV["DOPACC_DRY"]
+      puts JSON.generate(plan)
+    else
+      plan.each do |e|
+        if e[:show]
+          CC::Screen.show(e[:show], sub: e[:sub], palette: e[:palette], sound: e[:sound])
+        elsif e[:sound]
+          CC::Screen.play(e[:sound])
+        end
+      end
+    end
+  rescue StandardError, LoadError => e
+    warn "dopacc: #{e.class}: #{e.message}" if ENV["DOPACC_DEBUG"]
+  end
+  exit 0
+when "statusline"
+  $stdin.read unless $stdin.tty?
+  print CC.statusline
+when *CC::MODES
+  CC::State.update { |s| s["mode"] = cmd }
+  puts "dopacc: #{cmd}"
+when "status"
+  s = CC::State.read
+  puts "mode #{s["mode"]}  combo #{s["combo"]}  best #{s["best"]}  score #{CC::Hook.commas(s["score"])}  tools #{s["tools"]}"
+  puts "hooks #{CC::Installer.installed?(settings_path(args)) ? "installed" : "not installed"} (#{settings_path(args)})"
+when "install"
+  path = settings_path(args)
+  notes = CC::Installer.install(path, statusline: !args.include?("--no-statusline"))
+  puts "dopacc: hooks added to #{path}"
+  notes.each { |n| puts "  #{n}" }
+  puts "  restart Claude Code (or open /hooks) to start the show; `dopacc off` to pause it"
+when "uninstall"
+  path = settings_path(args)
+  CC::Installer.uninstall(path)
+  puts "dopacc: hooks removed from #{path}"
+when "demo"
+  shown = CC::Screen.show(args.empty? ? "DOPA CLAUDE!" : args.join(" "), sub: "dopacc demo")
+  warn "dopacc: no terminal found (run it from inside Claude Code: ! dopacc demo)" unless shown
+when nil, "-h", "--help", "help"
+  puts USAGE
+when "--version"
+  require_relative "../lib/dopairb/version"
+  puts "dopacc (dopairb #{Dopairb::VERSION})"
+else
+  warn USAGE
+  exit 2
+end

data/lib/dopairb/claude_code.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Dopairb
+  # dopacc: the dopairb show on top of Claude Code, driven by its hooks.
+  #
+  # Claude Code owns the terminal, so a hook finds Claude Code's tty by
+  # walking up the process tree, draws a full-screen banner on it and then
+  # makes Claude Code lay its screen out again by wiggling the window size.
+  # Everything here is cheap to load; the effects (`require "dopairb"`) are
+  # only loaded when something is actually drawn or played.
+  module ClaudeCode
+    MODES = %w[on calm off].freeze
+    HOOK_EVENTS = %w[PostToolUse PostToolUseFailure Stop].freeze
+    JACKPOT_CHANCE = 1 / 64.0
+    FEVER_COMBO = 10
+    DONE = ["MISSION COMPLETE!", "DONE!", "NICE WORK!", "GG!", "CLEAR!"].freeze
+
+    # Shared progress in a JSON file, updated under an exclusive lock
+    # because hooks of parallel tool calls run at the same time.
+    module State
+      DEFAULTS = { "mode" => "on", "session" => nil, "combo" => 0, "best" => 0, "score" => 0,
+                   "tools" => 0, "turn_tools" => 0, "turn_score" => 0 }.freeze
+
+      module_function
+
+      def path
+        ENV["DOPACC_STATE"] || File.join(ENV["XDG_STATE_HOME"] || File.expand_path("~/.local/state"), "dopairb", "dopacc.json")
+      end
+
+      def read
+        DEFAULTS.merge(JSON.parse(File.read(path)))
+      rescue SystemCallError, JSON::ParserError
+        DEFAULTS.dup
+      end
+
+      # Yields the state; whatever the block changes is written back.
+      def update
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, File::RDWR | File::CREAT, 0o644) do |f|
+          f.flock(File::LOCK_EX)
+          s = DEFAULTS.merge((JSON.parse(f.read) rescue {}))
+          result = yield s
+          f.rewind
+          f.truncate(0)
+          f.write(JSON.pretty_generate(s))
+          result
+        end
+      end
+    end
+
+    # One hook call: hook JSON in, a list of effects out.
+    module Hook
+      module_function
+
+      def run(input, rng: nil)
+        ev = (JSON.parse(input) rescue {})
+        return [] if %w[off 0 false].include?(ENV["DOPACC"].to_s)
+        mode = nil
+        plan = State.update do |s|
+          mode = s["mode"]
+          next [] if mode == "off"
+          rng ||= rng_for(s["tools"])
+          if s["session"] != ev["session_id"]
+            s.merge!("session" => ev["session_id"], "combo" => 0, "turn_tools" => 0, "turn_score" => 0)
+          end
+          case ev["hook_event_name"]
+          when "PostToolUse" then success(s, rng)
+          when "PostToolUseFailure" then failure(s)
+          when "Stop" then stop(s, rng)
+          else []
+          end
+        end
+        # calm: sounds only, never take the screen
+        plan = plan.map { |e| e[:show] ? { sound: e[:sound] } : e } if mode == "calm"
+        plan
+      end
+
+      # DOPACC_SEED makes the luck repeatable (for recordings), call by call.
+      def rng_for(tools)
+        ENV["DOPACC_SEED"] ? Random.new(ENV["DOPACC_SEED"].to_i * 1000 + tools) : Random.new
+      end
+
+      def success(s, rng)
+        s["combo"] += 1
+        s["tools"] += 1
+        s["turn_tools"] += 1
+        combo = s["combo"]
+        new_best = combo > s["best"]
+        s["best"] = combo if new_best
+        gain = (10 + combo) * (combo >= FEVER_COMBO ? 2 : 1)
+        jackpot = rng.rand < JACKPOT_CHANCE
+        gain *= 16 if jackpot
+        s["score"] += gain
+        s["turn_score"] += gain
+        if jackpot
+          [{ show: "JACKPOT!!", sub: "+#{commas(gain)} (x16)", palette: :GOLD, sound: :jackpot }]
+        elsif combo >= 8 && (combo & (combo - 1)).zero?
+          [{ show: "COMBO #{combo}!", sub: new_best ? "ALL-TIME BEST!" : "#{combo}-HIT CHAIN", palette: :FIRE, sound: :mega }]
+        else
+          [{ sound: combo >= FEVER_COMBO ? :hit : :nice }]
+        end
+      end
+
+      def failure(s)
+        broken = s["combo"] >= 4
+        s["combo"] = 0
+        [{ sound: broken ? :crack : :error }]
+      end
+
+      def stop(s, rng)
+        tools = s["turn_tools"]
+        score = s["turn_score"]
+        s["turn_tools"] = 0
+        s["turn_score"] = 0
+        # a plain answer (no tools) only gets a jingle
+        return [{ sound: :result }] if tools.zero?
+        [{ show: DONE.sample(random: rng), sub: "#{tools} TOOLS  +#{commas(score)}  COMBO #{s["combo"]}  BEST #{s["best"]}",
+           palette: :GOLD, sound: :mega }]
+      end
+
+      def commas(n) = n.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+    end
+
+    # Drawing on Claude Code's terminal from a hook process.
+    module Screen
+      module_function
+
+      # => [pid, "/dev/pts/N"] of the nearest ancestor that owns a terminal
+      def find(pid = Process.ppid)
+        while pid && pid > 1
+          tty = tty_of(pid)
+          return [pid, tty] if tty
+          pid = parent_of(pid)
+        end
+        nil
+      end
+
+      def tty_of(pid)
+        if File.directory?("/proc/#{pid}/fd")
+          [1, 2, 0].each do |fd|
+            t = (File.readlink("/proc/#{pid}/fd/#{fd}") rescue nil)
+            return t if t&.start_with?("/dev/pts/", "/dev/tty")
+          end
+          nil
+        else
+          t = `ps -o tty= -p #{pid.to_i} 2>/dev/null`.strip
+          t.empty? || t.start_with?("?", "-") ? nil : "/dev/#{t.delete_prefix("/dev/")}"
+        end
+      end
+
+      def parent_of(pid)
+        if File.exist?("/proc/#{pid}/stat")
+          File.read("/proc/#{pid}/stat")[/\) \S (\d+)/, 1]&.to_i
+        else
+          `ps -o ppid= -p #{pid.to_i} 2>/dev/null`.strip.then { |s| s.empty? ? nil : s.to_i }
+        end
+      rescue SystemCallError
+        nil
+      end
+
+      # Claude Code's fullscreen TUI already lives on the alternate screen;
+      # the classic one draws on the main screen.
+      def fullscreen?(cwd = Dir.pwd)
+        return false if truthy?(ENV["CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN"])
+        return true if truthy?(ENV["CLAUDE_CODE_NO_FLICKER"])
+        tui = nil
+        [File.expand_path("~/.claude/settings.json"), File.join(cwd, ".claude/settings.json"),
+         File.join(cwd, ".claude/settings.local.json")].each do |f|
+          v = (JSON.parse(File.read(f))["tui"] rescue nil)
+          tui = v if v
+        end
+        tui == "fullscreen"
+      end
+
+      def truthy?(v) = !v.nil? && !%w[0 false no off].include?(v.to_s.downcase) && !v.empty?
+
+      def show(text, sub: nil, palette: :GOLD, sound: :mega, secs: 2.0, cwd: Dir.pwd)
+        _pid, path = find
+        return false unless path
+        require_relative "../dopairb"
+        # hooks of parallel tool calls take turns on the screen
+        FileUtils.mkdir_p(File.dirname(State.path))
+        lock = File.open("#{State.path}.lock", File::RDWR | File::CREAT, 0o644)
+        lock.flock(File::LOCK_EX)
+        tty = File.open(path, "r+")
+        tty.sync = true
+        Term.out = tty
+        Term.input = tty
+        rows, cols = tty.winsize
+        swap = !fullscreen?(cwd)
+        play(sound) if sound
+        ctx = Ctx.new(w: cols - 1, rows: rows, depth: Term.depth(Config.new), config: Config.new, rng: Random.new,
+                      input: nil, pre: 0.0, compact: false)
+        banner = Scenes::Banner.new(ctx, nil, text: text, sub: sub, palette: Color.const_get(palette),
+                                              mega: true, rainbow: true, alt: true)
+        tty.write(swap ? "\e[?1049h\e[?25l\e[2J" : "\e7\e[?25l\e[2J")
+        t0 = now
+        while (t = now - t0) < secs
+          c = Canvas.new(cols - 1, rows)
+          banner.draw(c, t)
+          lines = c.render(ctx.depth, shake: banner.shake(t))
+          tty.write("\e[H" + lines.map { |l| "#{l}\e[0m\e[K" }.join("\r\n"))
+          sleep [1 / 30.0 - (now - t0 - t), 0].max
+        end
+        if swap
+          tty.write("\e[0m\e[?1049l\e[?25h")
+        else
+          # A real size change makes the TUI lay everything out again.
+          tty.write("\e[0m\e[2J\e8")
+          tty.winsize = [rows, cols - 1]
+          sleep 0.08
+          tty.winsize = [rows, cols]
+        end
+        true
+      ensure
+        tty&.close
+        lock&.close
+      end
+
+      # Players outlive the hook process, which exits right away.
+      def play(name)
+        require_relative "../dopairb"
+        kind, argv = Sound.backend
+        return false unless kind
+        return Sound.log_play(argv[0], name, 0.0, 1.0) if kind == :log # recordings
+        path, = Sound.file(name)
+        cmd = if kind == :slow
+                win = IO.popen(["wslpath", "-w", path], err: File::NULL, &:read).strip
+                argv + ["(New-Object Media.SoundPlayer '#{win}').PlaySync()"]
+              else
+                argv + [path]
+              end
+        Process.detach(Process.spawn(*cmd, in: File::NULL, out: File::NULL, err: File::NULL, pgroup: true))
+        true
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # `dopacc install`: hooks (and a status line) in Claude Code's settings.
+    module Installer
+      module_function
+
+      def command
+        bin = File.join(Gem.bindir, "dopacc") if defined?(Gem)
+        exe = if bin && File.exist?(bin) then bin
+              elsif File.basename($PROGRAM_NAME) == "dopacc" then File.expand_path($PROGRAM_NAME)
+              else "dopacc"
+              end
+        exe.include?(" ") ? "\"#{exe}\"" : exe
+      end
+
+      def ours?(hook) = hook["command"].to_s.match?(/dopacc(\"?)? hook\z/)
+
+      def install(settings_path, statusline: true)
+        s = load(settings_path)
+        strip!(s)
+        hooks = (s["hooks"] ||= {})
+        HOOK_EVENTS.each do |ev|
+          (hooks[ev] ||= []) << { "matcher" => "", "hooks" => [{ "type" => "command", "command" => "#{command} hook", "timeout" => 15 }] }
+        end
+        notes = []
+        if statusline
+          if s["statusLine"].nil? || s["statusLine"]["command"].to_s.include?("dopacc")
+            s["statusLine"] = { "type" => "command", "command" => "#{command} statusline" }
+          else
+            notes << "kept your statusLine; `dopacc statusline` prints the COMBO line if you want to add it"
+          end
+        end
+        save(settings_path, s)
+        notes
+      end
+
+      def uninstall(settings_path)
+        s = load(settings_path)
+        strip!(s)
+        s.delete("statusLine") if s["statusLine"].to_h["command"].to_s.include?("dopacc")
+        save(settings_path, s)
+      end
+
+      def installed?(settings_path)
+        load(settings_path).fetch("hooks", {}).values.flatten.any? { |m| m.fetch("hooks", []).any? { |h| ours?(h) } }
+      end
+
+      def strip!(s)
+        hooks = s["hooks"] or return
+        hooks.each_value do |matchers|
+          matchers.each { |m| m["hooks"]&.reject! { |h| ours?(h) } }
+          matchers.reject! { |m| m["hooks"]&.empty? }
+        end
+        hooks.reject! { |_, v| v.empty? }
+        s.delete("hooks") if hooks.empty?
+      end
+
+      def load(path)
+        File.exist?(path) ? JSON.parse(File.read(path)) : {}
+      end
+
+      def save(path, s)
+        FileUtils.mkdir_p(File.dirname(path))
+        FileUtils.cp(path, "#{path}.bak") if File.exist?(path)
+        tmp = "#{path}.#{Process.pid}.tmp"
+        File.write(tmp, JSON.pretty_generate(s) + "\n")
+        File.rename(tmp, path)
+      end
+    end
+
+    # `dopacc statusline`: one line, no effects library, fast.
+    def self.statusline(s = State.read)
+      return "\e[2mdopacc off\e[0m" if s["mode"] == "off"
+      combo = s["combo"]
+      fever = combo >= FEVER_COMBO
+      head = fever ? rainbow("FEVER!") + " " : ""
+      "#{head}\e[1;38;2;255;170;60mCOMBO #{combo}\e[0m  \e[38;2;255;220;120mSCORE #{Hook.commas(s["score"])}\e[0m  " \
+        "\e[2mBEST #{s["best"]}#{s["mode"] == "calm" ? "  (calm)" : ""}\e[0m"
+    end
+
+    def self.rainbow(str)
+      t = Time.now.to_f * 2
+      str.chars.each_with_index.map do |ch, i|
+        h = (t + i * 0.15) % 1.0
+        r, g, b = [0, 2, 4].map { |k| (Math.sin((h + k / 6.0) * 2 * Math::PI) * 127 + 128).round }
+        "\e[1;38;2;#{r};#{g};#{b}m#{ch}"
+      end.join + "\e[0m"
+    end
+  end
+end

data/lib/dopairb/session.rb

@@ -6,6 +6,8 @@ module Dopairb
   class Session
     attr_reader :config, :game, :director, :fx, :collected
     attr_accessor :cold_start
+    # Hooked into IRB but not playing: `require "dopairb"` without enable.
+    attr_accessor :dormant
 
     def initialize(config)
       @config = config
@@ -31,15 +33,15 @@ module Dopairb
     end
 
     def active?
-      !@config.off? && Term.interactive? && (@config.binding_irb || !IrbAdapter.from_binding?)
+      !@dormant && !@config.off? && Term.interactive? && (@config.binding_irb || !IrbAdapter.from_binding?)
     end
 
     # Once per process: from the dopairb command before IRB starts, or for
-    # `Dopairb.enable` in .irbrc right before the first prompt.
+    # `Dopairb.enable` in .irbrc right before the first prompt -- or, when it
+    # starts switched off, before the first prompt after `dopa on`.
     def intro
-      return if @introduced
+      return if @introduced || !active?
       @introduced = true
-      return unless active?
       prof = profile
       grew = prof.visit
       prof.save if grew

data/lib/dopairb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dopairb
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/dopairb.rb

@@ -68,26 +68,46 @@ module Dopairb
       overrides << [name, value]
     end
 
-    # Hook into IRB. Safe to call more than once; options are config settings.
+    # Hook into IRB and switch the show on. Safe to call more than once;
+    # options are config settings.
     def enable(intro: nil, **settings)
       settings.each { |k, v| config.set(k, v) }
       config.set(:intro, intro) unless intro.nil?
       overrides.each { |k, v| k == :string ? config.apply_string(v) : config.set(k, v) }
-      @session ||= Session.new(config)
-      if IrbAdapter.install
-        RelineAdapter.install(@session.fx)
-        OutputTap.install
-        if active?
-          # decided before warming up: the first run shows the loading screen
-          @session.cold_start = Sound.available? && !Sound.ready?(:intro, config.duration)
-          Sound.warm_up(config.duration)
-        end
+      if hook
+        wake
       else
         warn "dopairb: IRB #{defined?(IRB::VERSION) ? IRB::VERSION : '?'} is not supported; running plain IRB"
       end
       @session
     end
 
+    # Just add the `dopa` command; the show stays dormant until `dopa on` or
+    # Dopairb.enable. This is what a bare `require "dopairb"` inside IRB does.
+    def install
+      hook
+      @session
+    end
+
+    def hook
+      @session ||= Session.new(config)
+      return false unless IrbAdapter.install
+      RelineAdapter.install(@session.fx)
+      OutputTap.install
+      true
+    end
+
+    # Out of dormancy (into whatever the intensity says).
+    def wake
+      return unless @session
+      was = @session.dormant
+      @session.dormant = false
+      return unless active?
+      # decided before warming up: the first run shows the loading screen
+      @session.cold_start = Sound.available? && !Sound.ready?(:intro, config.duration) if was || @session.cold_start.nil?
+      Sound.warm_up(config.duration)
+    end
+
     def active?
       @session&.active? || false
     end
@@ -110,6 +130,7 @@ module Dopairb
 
     HELP = <<~TXT
       dopa                  show settings and session stats
+      dopa on / dopa off    switch the show on (back to where it was) or off
       dopa off|low|normal|max
       dopa calm             low intensity, no flash, shorter
       dopa party            max intensity, full-screen flash, sound effects
@@ -153,7 +174,11 @@ module Dopairb
       words = arg.split
       if words.empty? || words == ["status"]
         s = @session&.game
-        puts "dopairb #{VERSION}  (#{active? ? 'active' : 'inactive: not a terminal or intensity=off'})"
+        state = if active? then "active"
+                elsif @session&.dormant then "dormant: `dopa on` to start the show"
+                else "inactive: not a terminal or intensity=off"
+                end
+        puts "dopairb #{VERSION}  (#{state})"
         puts config.describe
         puts "  sound player: #{Sound.backend ? Sound.backend[1].first : '(none; bell only)'}   cache: #{Sound.dir}"
         puts "  session: #{s.evals} evals, #{s.successes} hits, #{s.failures} errors, max combo #{s.max_combo}, score #{Fx.number_with_commas(s.score)}" if s
@@ -174,7 +199,12 @@ module Dopairb
       elsif words == ["loading"]
         t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @session&.director&.loading { Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0 > 2.5 } if active?
+      elsif words == ["on"]
+        config.set(:intensity, @resume_intensity || Config.new.intensity) if config.off?
+        wake
+        puts "dopairb: on (#{config.intensity})"
       elsif words.size == 1 && PRESETS.key?(words[0])
+        @resume_intensity = config.intensity if words[0] == "off" && !config.off?
         PRESETS[words[0]].each { |k, v| config.set(k, v) }
         Sound.warm_up(config.duration) if active?
         puts "dopairb: #{words[0]}"
@@ -194,3 +224,6 @@ module Dopairb
     end
   end
 end
+
+# Required from inside IRB (e.g. .irbrc): add the `dopa` command, nothing else yet.
+Dopairb.install.dormant = true if defined?(IRB.conf) && IRB.conf[:AP_NAME] && !Dopairb.session

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dopairb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Koichi Sasada
@@ -55,16 +55,19 @@ description: 'dopairb extends IRB with game-like terminal effects: sparks while
 email:
 - ko1@atdot.net
 executables:
+- dopacc
 - dopairb
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- exe/dopacc
 - exe/dopairb
 - lib/dopairb.rb
 - lib/dopairb/canvas.rb
 - lib/dopairb/charge_line.rb
+- lib/dopairb/claude_code.rb
 - lib/dopairb/cli.rb
 - lib/dopairb/color.rb
 - lib/dopairb/config.rb