tempest-rb 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5f6d650f85e45e0d4f39f9ace3184141099dfacc7e499144157ccc3e1b9e1fa
-  data.tar.gz: 0d86da89ce1f2c8335d5a9d62911a8d86bc68e9f5e317e6b884aa898bd69227c
+  metadata.gz: c28613c22b61422cea99a83eb372bca8a1c1404c51f5d491846380bdd33d5196
+  data.tar.gz: efbfee28e847621e49afdc75da6d3ada58513dc16c29eaa29c1ef99753cb1336
 SHA512:
-  metadata.gz: cf7a05f136b292d36a01893f7ee83d8362b53ae2391e3dece56ef80b5d24f7dc0070dfadc12f6e49d1615649f69fa6511993cce0e7be272db36f5295cbc71cee
-  data.tar.gz: 0ee8b681779c0d7d54b51e85f5127c13d32923f90fb7c340e3c48ba49824bfab5a0600e5493523aba93723ad6b849826eaee933df7edd6746a06da6271d99e7a
+  metadata.gz: f1670a1a245c27a1177efca4ee74fc23f83d625b40fbabe368126d82d25c5866768800adabe2c16a38094b7abc03ee36138a5d72c51a83b39f0dfa0b019362b3
+  data.tar.gz: 5bdb09991abbf954111f27bce93b8d6d22900442f910f70994e97130cb657a52fd083005c889d4aa1bc15a0c35617e6c480363e9bfd63f1ffc0ef82646e8cfc8

data/README.md

@@ -62,7 +62,7 @@ The first sign-in may prompt for the email code Bluesky sends as a second factor
 
 Anything else you type is sent as a new post.
 
-Each post in the timeline is prefixed with a short `$XX` id, and URLs found inside posts get their own `$LX` ids. Use those ids with `$XX <text>` to reply or `:open $LX` to open a link.
+Each post in the timeline is prefixed with a short `$XX` id, and URLs found inside posts get their own `$LX` ids. Use those ids with `$XX <text>` to reply or `:open $LX` to open a link. Like and repost events show the subject post's `$XX` id in trailing brackets (for example `liked @bob's post [$AA]`) whenever the original post is still in the session registry, so you can reply to it directly.
 
 ### CLI options
 

data/lib/tempest/avatar_store.rb

@@ -0,0 +1,190 @@
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "tmpdir"
+require "uri"
+
+require_relative "../tempest"
+
+module Tempest
+  # Resolves Bluesky DIDs to a local PNG file path for the actor's avatar.
+  # Mirrors the shape of HandleResolver: an injected client speaks XRPC for
+  # `app.bsky.actor.getProfile`, and the result is cached in-process so the
+  # PDS isn't hit on every event.
+  #
+  # Disk layout: avatars live under `cache_dir/` as
+  # "<sanitized-did>__<avatar-cid>.png". The avatar CID is read from the
+  # tail of the avatar URL so that re-uploaded avatars (which receive a new
+  # CID) invalidate the cache without server-side coordination.
+  class AvatarStore
+    # Sentinel for "we tried, there is no avatar" — distinct from "we haven't
+    # looked yet" (nil). Mirrors the pattern in HandleResolver.
+    NOT_FOUND = Object.new.freeze
+
+    # Standalone profile client used by Tempest::CLI.
+    #
+    # AvatarStore resolves DIDs on a background thread, so the client it uses
+    # must be thread-safe. We deliberately do NOT use Tempest::XRPCClient
+    # here, because the underlying Tempest::HTTP layer is built on
+    # Async::HTTP::Internet whose Fibers cannot be resumed from a thread other
+    # than the one that created them — calling it from our worker yields
+    # `FiberError: fiber called across threads`.
+    #
+    # app.bsky.actor.getProfile is served unauthenticated by
+    # public.api.bsky.app, so we don't need a session here.
+    class DefaultProfileClient
+      HOST = "https://public.api.bsky.app".freeze
+
+      def get(nsid, query: nil)
+        uri = URI("#{HOST}/xrpc/#{nsid}")
+        uri.query = URI.encode_www_form(query) if query && !query.empty?
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.get(uri.request_uri, "Accept" => "application/json")
+        end
+        raise Tempest::APIError.new(res.code.to_i, { "error" => res.message }) unless res.is_a?(Net::HTTPSuccess)
+        JSON.parse(res.body)
+      end
+    end
+
+    def initialize(client:, cache_dir:, fetcher: nil, converter: nil, async: true, executor: nil)
+      @client = client
+      @cache_dir = cache_dir
+      @fetcher = fetcher || self.class.default_fetcher
+      @converter = converter || self.class.default_converter
+      @async = async
+      @executor = executor || method(:default_executor)
+      @cache = {}
+      @pending = {}
+      @mutex = Mutex.new
+      FileUtils.mkdir_p(@cache_dir)
+    end
+
+    # Production HTTP fetcher used when no fetcher is injected. Returns the
+    # raw bytes and Content-Type header so the converter can pick the right
+    # input format.
+    def self.default_fetcher
+      @default_fetcher ||= lambda do |url|
+        uri = URI(url)
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.get(uri.request_uri)
+        end
+        unless res.is_a?(Net::HTTPSuccess)
+          raise Tempest::APIError.new(res.code.to_i, { "error" => res.message })
+        end
+        [res.body, res["content-type"].to_s]
+      end
+    end
+
+    # Production format normalizer: shells out to ImageMagick to crop-fit the
+    # avatar into a 128x128 PNG. The crop pads non-square inputs so the Kitty
+    # graphics protocol can render at a consistent 1-row, 2-col aspect.
+    def self.default_converter
+      @default_converter ||= lambda do |bytes, content_type:|
+        ext = ext_for(content_type, bytes)
+        Dir.mktmpdir do |dir|
+          src = File.join(dir, "src.#{ext}")
+          dst = File.join(dir, "out.png")
+          File.binwrite(src, bytes)
+          _out, status = Open3.capture2e(
+            "magick", src,
+            "-resize", "128x128^",
+            "-gravity", "center",
+            "-extent", "128x128",
+            dst,
+          )
+          raise "magick convert failed" unless status.success?
+          File.binread(dst)
+        end
+      end
+    end
+
+    EXT_BY_MIME = {
+      "image/jpeg" => "jpg",
+      "image/jpg" => "jpg",
+      "image/png" => "png",
+      "image/webp" => "webp",
+      "image/gif" => "gif",
+      "image/avif" => "avif",
+    }.freeze
+
+    def self.ext_for(content_type, bytes)
+      mime = content_type.to_s.split(";").first.to_s.strip.downcase
+      return EXT_BY_MIME[mime] if EXT_BY_MIME.key?(mime)
+      head = bytes.byteslice(0, 16).to_s
+      return "jpg"  if head.start_with?("\xFF\xD8\xFF".b)
+      return "png"  if head.start_with?("\x89PNG\r\n\x1A\n".b)
+      return "gif"  if head.start_with?("GIF87a", "GIF89a")
+      return "webp" if head[0, 4] == "RIFF" && head[8, 4] == "WEBP"
+      "bin"
+    end
+
+    def path_for(did)
+      cached = @mutex.synchronize { @cache[did] }
+      return cached_value(cached) unless cached.nil?
+
+      if @async
+        enqueue_resolve(did)
+        nil
+      else
+        resolve_and_cache(did)
+      end
+    end
+
+    def seed(did, path)
+      @mutex.synchronize { @cache[did] = path }
+    end
+
+    private
+
+    def cached_value(value)
+      value.equal?(NOT_FOUND) ? nil : value
+    end
+
+    def resolve_and_cache(did)
+      path = resolve_sync(did)
+      @mutex.synchronize { @cache[did] = path.nil? ? NOT_FOUND : path }
+      path
+    end
+
+    def enqueue_resolve(did)
+      should_dispatch = @mutex.synchronize do
+        next false if @pending[did]
+        @pending[did] = true
+        true
+      end
+      return unless should_dispatch
+
+      @executor.call do
+        begin
+          resolve_and_cache(did)
+        ensure
+          @mutex.synchronize { @pending.delete(did) }
+        end
+      end
+    end
+
+    def default_executor(&block)
+      Thread.new(&block)
+    end
+
+    def resolve_sync(did)
+      profile = @client.get("app.bsky.actor.getProfile", query: { "actor" => did })
+      avatar_url = profile.is_a?(Hash) ? profile["avatar"] : nil
+      return nil if avatar_url.nil? || avatar_url.empty?
+
+      bytes, content_type = @fetcher.call(avatar_url)
+      png = @converter.call(bytes, content_type: content_type)
+      cid = File.basename(URI(avatar_url).path)
+      path = File.join(@cache_dir, "#{sanitize(did)}__#{cid}.png")
+      File.binwrite(path, png)
+      path
+    rescue Tempest::APIError, StandardError
+      nil
+    end
+
+    def sanitize(did)
+      did.gsub(/[^A-Za-z0-9._-]/, "_")
+    end
+  end
+end

data/lib/tempest/cli.rb

@@ -7,6 +7,7 @@ require_relative "cursor_store"
 require_relative "timeline_store"
 require_relative "xrpc_client"
 require_relative "handle_resolver"
+require_relative "avatar_store"
 require_relative "follows"
 require_relative "jetstream/client"
 require_relative "jetstream/stream_manager"
@@ -46,6 +47,16 @@ module Tempest
       handle_resolver = Tempest::HandleResolver.new(client: client)
       handle_resolver.seed(session.did, session.handle)
 
+      # NOTE: we intentionally don't pass `client` (the XRPCClient) here.
+      # XRPCClient routes through Tempest::HTTP / Async, whose Fibers cannot
+      # be resumed across threads; AvatarStore runs resolution in background
+      # workers. DefaultProfileClient is a plain Net::HTTP client that hits
+      # public.api.bsky.app unauthenticated, which is thread-safe.
+      avatar_store = Tempest::AvatarStore.new(
+        client: Tempest::AvatarStore::DefaultProfileClient.new,
+        cache_dir: avatar_cache_dir(env),
+      )
+
       mode = feed_mode(argv: argv, env: env)
       plan = build_subscription(
         mode: mode, session: session, client: client,
@@ -86,6 +97,7 @@ module Tempest
         stream_output: screen.enabled? ? screen : Tempest::REPL::AsyncOutput.new(stdout),
         stream_manager: stream_manager,
         handle_resolver: handle_resolver,
+        avatar_store: avatar_store,
         timeline_store: timeline_store(env),
         opener: opener_for(env: env),
       )
@@ -194,6 +206,14 @@ module Tempest
       Tempest::TimelineStore.new(path: Tempest::TimelineStore.default_path(env))
     end
 
+    def avatar_cache_dir(env)
+      override = env["TEMPEST_AVATAR_CACHE_DIR"]
+      return override if override && !override.empty?
+      base = env["XDG_CACHE_HOME"]
+      base = File.join(env["HOME"] || Dir.home, ".cache") if base.nil? || base.empty?
+      File.join(base, "tempest", "avatars")
+    end
+
     def opener_for(env:, system_proc: Kernel.method(:system))
       cmd = env["TEMPEST_OPEN_CMD"]
       return Tempest::REPL::Runner::DEFAULT_OPENER if cmd.nil? || cmd.empty?

data/lib/tempest/jetstream/stream_manager.rb

@@ -143,6 +143,12 @@ module Tempest
               now = @clock.call
               @mutex.synchronize { @last_event_at = now }
               if event.respond_to?(:time_us) && event.time_us
+                # Replay protection: when reconnecting with a preserved cursor,
+                # Jetstream re-yields events at or below the cursor (the cursor
+                # is inclusive). Drop them so downstream sees each event once.
+                # last_event_at above is still updated, so the watchdog
+                # correctly sees the connection as alive.
+                next if cursor && event.time_us <= cursor
                 cursor = event.time_us
                 @mutex.synchronize { @cursor_state[:live] = cursor }
                 if @cursor_store && cursor != last_saved_cursor

data/lib/tempest/jetstream/watchdog.rb

@@ -11,8 +11,13 @@ module Tempest
     # therefore never runs. The watchdog periodically inspects
     # `stream_manager.last_event_at` and, if no event has arrived within
     # `threshold_seconds`, calls `force_reconnect` to break the stalled call.
+    #
+    # The threshold has to be long enough that a quiet but healthy stream
+    # (e.g. `--feed=self`, where only the user's own posts come through)
+    # doesn't trip it. macOS sleeps are typically minutes to hours, so 10
+    # minutes catches real stalls without flapping on idle streams.
     class Watchdog
-      DEFAULT_THRESHOLD_SECONDS = 90
+      DEFAULT_THRESHOLD_SECONDS = 600
       DEFAULT_INTERVAL_SECONDS = 30
 
       def initialize(stream_manager:,

data/lib/tempest/kitty.rb

@@ -0,0 +1,48 @@
+require "base64"
+
+require_relative "../tempest"
+
+module Tempest
+  # Encodes an image as a Kitty graphics protocol "transmit and display"
+  # escape sequence. Pure transformation: no I/O beyond optionally reading
+  # the bytes from a path. Output is meant to be inlined into a single
+  # terminal row when called with the defaults (rows: 1, cols: 2).
+  #
+  # Protocol reference:
+  #   https://sw.kovidgoyal.net/kitty/graphics-protocol/
+  #
+  # Key control opcodes used:
+  #   a=T   transmit and immediately display
+  #   f=100 source bytes are PNG
+  #   r=N   render at N terminal rows
+  #   c=N   render at N terminal columns
+  #   C=1   do not advance the cursor (image is drawn at the current cell,
+  #         the cursor stays where it was)
+  #   m=0/1 multi-chunk marker: 1 = more chunks follow, 0 = final chunk
+  module Kitty
+    CHUNK_BYTES = 4096
+
+    module_function
+
+    def inline(png, rows: 1, cols: 2)
+      bytes = png.is_a?(String) && File.file?(png) ? File.binread(png) : png
+      data = Base64.strict_encode64(bytes)
+      out = String.new
+      pos = 0
+      first = true
+      while pos < data.bytesize
+        piece = data.byteslice(pos, CHUNK_BYTES)
+        pos += CHUNK_BYTES
+        more = pos < data.bytesize ? 1 : 0
+        controls = if first
+          "a=T,f=100,r=#{rows},c=#{cols},C=1,m=#{more}"
+        else
+          "m=#{more}"
+        end
+        out << "\e_G#{controls};#{piece}\e\\"
+        first = false
+      end
+      out
+    end
+  end
+end

data/lib/tempest/post.rb

@@ -43,6 +43,9 @@ module Tempest
         record["reply"] = { "root" => ref, "parent" => ref }
       end
 
+      link_facets = detect_link_facets(text)
+      record["facets"] = link_facets unless link_facets.empty?
+
       client.post(
         "com.atproto.repo.createRecord",
         body: {
@@ -52,5 +55,29 @@ module Tempest
         },
       )
     end
+
+    # Scans `text` for bare URLs and builds AT Protocol link facets pointing
+    # at each match. Without this, the AppView treats URLs as plain text and
+    # does not render them as clickable links.
+    def self.detect_link_facets(text)
+      return [] if text.nil? || text.empty?
+
+      bytes = text.b
+      facets = []
+      pos = 0
+      while (match = /https?:\/\/\S+/n.match(bytes, pos))
+        byte_start = match.begin(0)
+        byte_end = match.end(0)
+        uri = match[0].dup.force_encoding(Encoding::UTF_8)
+        facets << {
+          "index" => { "byteStart" => byte_start, "byteEnd" => byte_end },
+          "features" => [
+            { "$type" => "app.bsky.richtext.facet#link", "uri" => uri },
+          ],
+        }
+        pos = byte_end
+      end
+      facets
+    end
   end
 end

data/lib/tempest/repl/formatter.rb

@@ -2,6 +2,7 @@ require "time"
 require "uri"
 
 require_relative "../../tempest"
+require_relative "../kitty"
 
 module Tempest
   module REPL
@@ -31,13 +32,14 @@ module Tempest
 
       module_function
 
-      def post_line(post, registry: nil)
+      def post_line(post, registry: nil, avatar_store: nil)
         var = registry&.assign_post(post)
         facets = post.respond_to?(:facets) ? post.facets : nil
         body = annotate_urls(squeeze(post.text), registry, facets: facets)
         body = decorate_body(body)
         body = prepend_reply_marker(body, reply_parent_uri_of(post), registry)
-        compose(var, format_time(post.created_at), post.handle, nil, body)
+        icon = avatar_icon(post_did(post), avatar_store)
+        compose(var, format_time(post.created_at), post.handle, nil, body, icon: icon)
       end
 
       def decorate_body(text)
@@ -70,16 +72,16 @@ module Tempest
         time.respond_to?(:localtime) ? time.localtime.strftime("%H:%M") : time.to_s
       end
 
-      def event_line(event, registry: nil, resolver: nil)
+      def event_line(event, registry: nil, resolver: nil, avatar_store: nil)
         handle = resolver&.resolve(event.did)
         if event.operation == :delete
           body = "(deleted #{event.collection}/#{event.rkey})"
           var = nil
         elsif event.respond_to?(:like?) && event.like?
-          body = "liked #{subject_owner_label(event.subject_uri, resolver)}"
+          body = "liked #{subject_owner_label(event.subject_uri, resolver, registry)}"
           var = nil
         elsif event.respond_to?(:repost?) && event.repost?
-          body = "reposted #{subject_owner_label(event.subject_uri, resolver)}"
+          body = "reposted #{subject_owner_label(event.subject_uri, resolver, registry)}"
           var = nil
         else
           facets = event.respond_to?(:facets) ? event.facets : nil
@@ -88,16 +90,22 @@ module Tempest
           body = prepend_reply_marker(body, reply_parent_uri_of(event), registry)
           var = registry&.assign_post(event)
         end
-        compose(var, format_time(event.created_at), handle, event.did, body)
+        icon = avatar_icon(event.did, avatar_store)
+        compose(var, format_time(event.created_at), handle, event.did, body, icon: icon)
       end
 
-      def subject_owner_label(subject_uri, resolver)
+      def subject_owner_label(subject_uri, resolver, registry = nil)
         did = subject_did(subject_uri)
         return "a post" unless did
 
         handle = resolver&.resolve(did)
         owner = handle ? handle_label(handle) : did_label(did)
-        "#{owner}'s post"
+        label = "#{owner}'s post"
+        var = registry&.var_for_uri(subject_uri)
+        return label unless var
+
+        bracket = Formatter.color ? "#{DIM}[#{var}]#{RESET}" : "[#{var}]"
+        "#{label} #{bracket}"
       end
 
       def subject_did(subject_uri)
@@ -177,14 +185,34 @@ module Tempest
         nil
       end
 
-      def compose(var, time, handle, did, text)
+      def compose(var, time, handle, did, text, icon: nil)
         prefix = ""
         prefix += id_label(var) if var
         prefix += bracket(time) if time
         identity = handle ? handle_label(handle) : did_label(did)
+        identity = "#{icon} #{identity}" if icon
         "#{prefix}#{identity}: #{text}"
       end
 
+      # DID for a Post is extracted from its at:// URI, since Post itself only
+      # carries handle. AvatarStore is keyed by DID, so we have to derive it.
+      def post_did(post)
+        return nil unless post.respond_to?(:uri)
+        subject_did(post.uri)
+      end
+
+      # Returns the Kitty graphics escape for this DID's avatar, or nil when
+      # avatars are off, the store has nothing yet, or colors are disabled
+      # (test mode mirrors today's color suppression so snapshots stay clean).
+      def avatar_icon(did, avatar_store)
+        return nil unless avatar_store
+        return nil unless Formatter.color
+        return nil if did.nil? || did.empty?
+        path = avatar_store.path_for(did)
+        return nil if path.nil?
+        Kitty.inline(path)
+      end
+
       def bracket(time)
         Formatter.color ? "#{CYAN}[#{time}]#{RESET} " : "[#{time}] "
       end

data/lib/tempest/repl/runner.rb

@@ -30,7 +30,8 @@ module Tempest
 
       def initialize(session:, client:, input:, output:, dispatcher: Dispatcher.new,
                      stream_manager: nil, handle_resolver: nil, stream_output: nil,
-                     timeline_store: nil, registry: Registry.new, opener: DEFAULT_OPENER)
+                     timeline_store: nil, registry: Registry.new, opener: DEFAULT_OPENER,
+                     avatar_store: nil)
         @session = session
         @client = client
         @input = input
@@ -42,6 +43,12 @@ module Tempest
         @timeline_store = timeline_store
         @registry = registry
         @opener = opener
+        @avatar_store = avatar_store
+        # URIs already printed via bootstrap_timeline or backfill_timeline.
+        # Jetstream's cursor-replay can re-emit those same posts on startup
+        # (the persisted cursor is older than the getTimeline window), so the
+        # stream handler skips post events whose URI is in this set.
+        @displayed_post_uris = Set.new
       end
 
       def bootstrap_timeline
@@ -49,7 +56,7 @@ module Tempest
 
         cached = @timeline_store.load
         cached_posts = cached ? Array(cached[:posts]) : []
-        cached_posts.each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+        cached_posts.each { |post| print_post(post) }
 
         cached_uris = cached_posts.map(&:uri).to_set
         begin
@@ -60,7 +67,7 @@ module Tempest
         end
 
         new_posts = fetched.reject { |post| cached_uris.include?(post.uri) }
-        new_posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+        new_posts.reverse_each { |post| print_post(post) }
 
         merged = cached_posts + new_posts.reverse
         @timeline_store.save(posts: merged)
@@ -116,7 +123,7 @@ module Tempest
         if posts.empty?
           @output.puts "(empty timeline)"
         else
-          posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+          posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry, avatar_store: @avatar_store) }
           @timeline_store&.save(posts: posts.reverse)
         end
       rescue Tempest::Error => e
@@ -202,17 +209,27 @@ module Tempest
         else
           return unless event.respond_to?(:create?) && event.create?
           return unless event.post? || event.like? || event.repost?
+          return if event.post? && @displayed_post_uris.include?(event.at_uri)
 
-          @stream_output.puts Formatter.event_line(event, registry: @registry, resolver: @handle_resolver)
+          @stream_output.puts Formatter.event_line(event, registry: @registry, resolver: @handle_resolver, avatar_store: @avatar_store)
+          @displayed_post_uris << event.at_uri if event.post?
         end
       end
 
       def backfill_timeline
         posts = Timeline.fetch(@client)
-        posts.reverse_each { |post| @stream_output.puts Formatter.post_line(post, registry: @registry) }
+        posts.reverse_each do |post|
+          next if @displayed_post_uris.include?(post.uri)
+          print_post(post, output: @stream_output)
+        end
       rescue Tempest::Error => e
         @stream_output.puts "-- timeline backfill failed: #{e.message}"
       end
+
+      def print_post(post, output: @output)
+        output.puts Formatter.post_line(post, registry: @registry, avatar_store: @avatar_store)
+        @displayed_post_uris << post.uri
+      end
     end
   end
 end

data/lib/tempest/repl/screen.rb

@@ -1,3 +1,4 @@
+require "reline"
 require_relative "../../tempest"
 
 module Tempest
@@ -13,9 +14,10 @@ module Tempest
     #   CSI row;col H     move cursor
     #   ESC 7 / ESC 8     save/restore cursor (DECSC/DECRC)
     class Screen
-      def initialize(io:, rows: nil)
+      def initialize(io:, rows: nil, cols: nil)
         @io = io
         @rows = rows
+        @cols = cols
         @enabled = false
         @mutex = Mutex.new
       end
@@ -26,6 +28,7 @@ module Tempest
         return unless rows && rows >= 4
 
         @rows = rows
+        @cols ||= detect_cols
         @io.print "\e[1;#{rows - 1}r"   # scrolling region: rows 1..rows-1
         @io.print "\e[#{rows};1H"        # park cursor on the final row (prompt)
         @io.flush if @io.respond_to?(:flush)
@@ -98,16 +101,41 @@ module Tempest
         nil
       end
 
+      def detect_cols
+        return nil unless defined?(IO) && IO.respond_to?(:console)
+        console = IO.console
+        return nil unless console
+        _rows, cols = console.winsize
+        cols
+      rescue StandardError
+        nil
+      end
+
+      # The terminal would otherwise wrap a line that overflows `@cols` past
+      # the bottom of the scrolling region and into the prompt row. Split the
+      # line into width-bounded chunks so each one fits and scrolls the region
+      # cleanly.
       def insert_above_prompt(line)
+        chunks = wrap_to_cols(line)
         bottom_of_region = @rows - 1
         @io.print "\e7"                       # save cursor
-        @io.print "\e[#{bottom_of_region};1H" # move to last row of scrolling region
-        @io.print "\r\e[2K"                   # clear that row first
-        @io.print "#{line}\n"                 # write line; \n scrolls region up by 1
+        chunks.each do |chunk|
+          @io.print "\e[#{bottom_of_region};1H" # move to last row of scrolling region
+          @io.print "\r\e[2K"                   # clear that row first
+          @io.print "#{chunk}\n"                # write chunk; \n scrolls region up by 1
+        end
         @io.print "\e8"                       # restore cursor
         @io.flush if @io.respond_to?(:flush)
       end
 
+      def wrap_to_cols(line)
+        return [line] unless @cols && @cols.positive?
+        return [line] if Reline::Unicode.calculate_width(line, true) <= @cols
+
+        chunks, _ = Reline::Unicode.split_by_width(line, @cols)
+        chunks.compact.reject(&:empty?)
+      end
+
       def rerender_prompt
         return unless defined?(Reline)
         Reline.line_editor&.rerender

data/lib/tempest/version.rb

@@ -1,3 +1,3 @@
 module Tempest
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tempest-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Yuya Fujiwara
@@ -92,6 +92,7 @@ files:
 - README.md
 - exe/tempest
 - lib/tempest.rb
+- lib/tempest/avatar_store.rb
 - lib/tempest/cli.rb
 - lib/tempest/config.rb
 - lib/tempest/cursor_store.rb
@@ -106,6 +107,7 @@ files:
 - lib/tempest/jetstream/stream_manager.rb
 - lib/tempest/jetstream/subscription.rb
 - lib/tempest/jetstream/watchdog.rb
+- lib/tempest/kitty.rb
 - lib/tempest/post.rb
 - lib/tempest/repl/async_output.rb
 - lib/tempest/repl/dispatcher.rb