rubino-agent 0.5.2.1 → 0.5.2.2

data/lib/rubino/ui/streaming_markdown.rb

@@ -56,6 +56,13 @@ module Rubino
       # produced the "1. Mercury / 1. Venus / 1. Earth" off-by-one (B4).
       LIST_ITEM_RE = /\A\s*(?:[-*+]|\d+[.)])\s/
 
+      # An ATX heading: 1-6 `#` (up to 3 leading spaces) followed by a space or
+      # end-of-line. CommonMark makes this a SINGLE-LINE block that can interrupt
+      # a paragraph, so the splitter commits it on its own — that's what lets a
+      # heading render WITH its H1/H2 breathing-room spacing live, instead of
+      # staying glued inside a multi-line block stuck in the capped live tail.
+      ATX_HEADING_RE = /\A {0,3}\#{1,6}(?:\s|\z)/
+
       # A GFM pipe-table separator row, e.g. "|---|:--:|---|" or "---|---". The
       # EXACT regex MarkdownRenderer uses to detect a table (markdown_renderer.rb)
       # — DRY: a separator row is the single unambiguous "this is a table" signal,
@@ -124,8 +131,7 @@ module Rubino
         while (idx = @pending.index("\n"))
           line = @pending[0...idx]
           @pending = @pending[(idx + 1)..] || +""
-          block = consume_line(line)
-          completed << block if block
+          completed.concat(consume_line(line))
         end
 
         completed
@@ -140,6 +146,34 @@ module Rubino
         parts.join("\n")
       end
 
+      # How many trailing lines of the in-flight block the LIVE markdown preview
+      # ever needs as render input. We only SHOW the last few rendered rows
+      # (CLI::LIVE_TAIL_ROWS), so feeding the renderer more than a screenful of
+      # source is wasted work: it re-parses the WHOLE growing block on EVERY
+      # delta and throws all but the last rows away — O(N²), which freezes the
+      # stream once a long ``` fence (a streamed file/code dump) accumulates.
+      # Generous enough that ordinary prose/lists/tables still render in full.
+      LIVE_SOURCE_MAX_LINES = 60
+
+      # Bounded source text for the LIVE markdown preview (#show_live_markdown):
+      # at most the last +max_lines+ lines of the in-flight block. When the block
+      # is inside a code fence the OPENER line (```lang) is always prepended so
+      # the windowed tail still parses AS a fenced block (same language, same box
+      # framing) — which makes the rendered last-LIVE_TAIL_ROWS rows identical to
+      # rendering the whole block, just without the quadratic cost. Outside a
+      # fence the cap only bites a pathologically long loose list (the one other
+      # unbounded block type); its transient numbering may differ for a frame,
+      # which beats freezing. Small blocks return the full #tail unchanged.
+      def live_source(max_lines = LIVE_SOURCE_MAX_LINES)
+        lines = @block.dup
+        lines << @pending unless @pending.empty?
+        return lines.join("\n") if lines.length <= max_lines
+
+        window = lines.last(max_lines)
+        window.unshift(@block.find { |l| l.match?(FENCE_OPEN_RE) }) if @in_fence
+        window.compact.join("\n")
+      end
+
       # The in-progress tail to show live (raw): the LAST +rows+ lines of the
       # in-flight block — its most recent already-newlined lines plus the
       # un-newlined remainder. Newline-joined; the live region renders one row
@@ -190,16 +224,18 @@ module Rubino
       private
 
       # Feed one complete (newline-stripped) line through the state machine.
-      # Returns the finished block's text when this line closes a block, else nil.
+      # Returns the block texts this line COMPLETED — usually 0 or 1, but a
+      # heading can close the open block AND emit itself, so the contract is an
+      # Array (feed concats them; the public #feed already returns an array).
       def consume_line(line)
         if @in_fence
           @block << line
-          return nil unless fence_line_closes?(line)
+          return [] unless fence_line_closes?(line)
 
           @in_fence = false
           @fence_len = 0
           @fence_depth = nil
-          return take_block
+          return [take_block]
         end
 
         if (m = line.match(FENCE_OPEN_RE)) # opening fence starts a code block
@@ -212,7 +248,7 @@ module Rubino
           @fence_depth = MARKDOWN_FENCE_LANGS.include?(m[2].to_s.strip.downcase) ? 1 : nil
           flush_blanks
           @block << line
-          return nil
+          return []
         end
 
         # A GFM pipe table is its own block type (like a fence): handled in
@@ -220,8 +256,15 @@ module Rubino
         # header-ish row), holds its rows, and closes it on a blank/non-row line.
         # Returns a 2-tuple [handled?, completed_block_or_nil].
         handled, table_block = consume_table_line(line)
-        return table_block if handled
+        return Array(table_block) if handled
 
+        consume_prose_line(line)
+      end
+
+      # A non-fence, non-table line: blank separators, ATX headings, list items,
+      # and plain prose. Returns the block texts this line completed (see
+      # #consume_line for the Array contract).
+      def consume_prose_line(line)
         if line.strip.empty?
           # A blank line inside a list is BUFFERED, not a separator: it only ends
           # the block if the list doesn't continue (handled when the next
@@ -229,11 +272,23 @@ module Rubino
           # blank line ends the current prose block (separator consumed).
           if @in_list
             @blanks += 1
-            return nil
+            return []
           end
-          return nil if @block.empty?
+          return [] if @block.empty?
+
+          return [take_block]
+        end
 
-          return take_block
+        # An ATX heading is a single-line block that can interrupt a paragraph
+        # (ATX_HEADING_RE). Close any open block first (dropping a list's trailing
+        # separator blank, like the list-exit path below), then emit the heading
+        # on its OWN so it commits — and renders with its breathing-room spacing —
+        # the instant it arrives, instead of staying glued in the capped live tail
+        # with the following lines until the whole block ends.
+        if line.match?(ATX_HEADING_RE)
+          @blanks = 0 if @in_list
+          finished = @block.empty? ? [] : [take_block]
+          return finished + [line]
         end
 
         is_item = line.match?(LIST_ITEM_RE)
@@ -245,13 +300,13 @@ module Rubino
           @blanks = 0 # drop the trailing blank(s) that separated list from this line
           finished = take_block
           @block << line
-          return finished
+          return [finished]
         end
 
         flush_blanks
         @in_list = true if is_item
         @block << line
-        nil
+        []
       end
 
       # Does this line (already appended to the open fence's block) CLOSE that

data/lib/rubino/ui/subagent_cards.rb

@@ -71,13 +71,14 @@ module Rubino
         else
           glyph = @pastel.cyan(COLLAPSED)
           state = entry.status == :stopping ? "stopping" : "running"
-          count = entry.tool_count.to_i
-          # Compact card: id · label · state · N tools · elapsed. The per-tool
-          # last_activity (often a long grep/glob arg or absolute path) is NOT
-          # shown here — too noisy on the always-visible card; the live detail
-          # lives in the agent's own view (Enter) / drill-in.
-          body = "#{entry.id} · #{safe(card_label(entry))} · #{state} · " \
-                 "#{count} tool#{"s" if count != 1} · #{elapsed(entry)}"
+          # Compact card: id · label · state · [N tools ·] elapsed. The tool count
+          # shows only when the entry HAS one (subagents); a background shell runs
+          # no tools, so its tool_count is nil and the segment is omitted instead of
+          # a meaningless "0 tools". last_activity is NOT shown — too noisy on the
+          # always-visible card; the live detail lives in the agent's view (Enter).
+          count  = entry.tool_count
+          metric = count ? "#{count.to_i} tool#{"s" if count.to_i != 1} · " : ""
+          body = "#{entry.id} · #{safe(card_label(entry))} · #{state} · #{metric}#{elapsed(entry)}"
           "  #{glyph} #{body}"
         end
       end

data/lib/rubino/ui/tool_args_stream.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Rubino
+  module UI
+    # Decodes a tool call's JSON arguments AS THEY STREAM into readable text, so
+    # the timeline can show what a `write`/`edit`/`shell` is composing while the
+    # model is still emitting it (#608). It surfaces the JSON string VALUES only
+    # (the `content` a write is producing, the `command` a shell will run) and
+    # drops the keys/structure, JSON-unescaping as it goes.
+    #
+    # #feed returns the COMPLETE decoded lines available so far (each ending in
+    # "\n"), holding the partial last line back until its newline lands so the
+    # caller never renders a half-line that the next fragment continues. #flush
+    # returns whatever partial remains at the end of the call.
+    #
+    # Single pass, O(n): fragments are concatenated only across an incomplete
+    # trailing escape (a "\\" or "\\uXXX" split mid-fragment), carried to the next
+    # feed so an escape is never decoded half-formed.
+    class ToolArgsStream
+      # JSON single-char escapes → their literal char (\uXXXX is handled inline).
+      UNESCAPE = { "n" => "\n", "t" => "\t", "r" => "\r", "b" => "\b",
+                   "f" => "\f", '"' => '"', "\\" => "\\", "/" => "/" }.freeze
+
+      def initialize
+        @in_string  = false
+        @is_value   = false      # the current string is a VALUE (emit) vs a KEY (skip)
+        @containers = []         # stack of :obj / :arr to read `,` correctly
+        @expect     = :value     # what the next opening string is (top-level value)
+        @line       = +""        # decoded VALUE text not yet returned (current line)
+        @carry      = +""        # raw chars held back across an incomplete escape
+      end
+
+      # Feed a raw argument fragment; returns the complete decoded lines unlocked
+      # by it (possibly empty), with the partial last line held back.
+      def feed(fragment)
+        return "" if fragment.nil? || fragment.empty?
+
+        scan(@carry + fragment)
+        take_complete_lines
+      end
+
+      # Final partial line (the value tail with no trailing newline), or "".
+      def flush
+        out = @line.dup
+        @line.clear
+        out
+      end
+
+      private
+
+      # Walks chars, decoding string VALUES into @line. Stops early and stashes
+      # an incomplete trailing escape into @carry so it is completed next feed.
+      def scan(buf)
+        @carry = +""
+        i = 0
+        n = buf.length
+        while i < n
+          ch = buf[i]
+          if @in_string
+            if ch == "\\"
+              consumed = decode_escape(buf, i)
+              return if consumed.nil? # incomplete escape → carried, wait for more
+
+              i += consumed
+              next
+            elsif ch == '"'
+              close_string
+            elsif @is_value
+              @line << ch
+            end
+          else
+            structural(ch)
+          end
+          i += 1
+        end
+      end
+
+      # Handles a backslash escape at buf[pos]. Returns the number of chars
+      # consumed (>=2), or nil when the escape is split across the fragment
+      # boundary (the raw tail is stashed in @carry to retry on the next feed).
+      def decode_escape(buf, pos)
+        nxt = buf[pos + 1]
+        return carry(buf[pos..]) if nxt.nil?
+
+        if nxt == "u"
+          hex = buf[pos + 2, 4]
+          return carry(buf[pos..]) if hex.nil? || hex.length < 4
+
+          @line << [hex.to_i(16)].pack("U") if @is_value
+          6
+        else
+          @line << UNESCAPE.fetch(nxt, nxt) if @is_value
+          2
+        end
+      end
+
+      # Stash the unfinished tail and signal "incomplete" to #scan.
+      def carry(tail)
+        @carry = tail.dup
+        nil
+      end
+
+      def structural(chr)
+        case chr
+        when '"'
+          @in_string = true
+          @is_value  = (@expect == :value)
+        when "{"
+          @containers.push(:obj)
+          @expect = :key
+        when "["
+          @containers.push(:arr)
+          @expect = :value
+        when "}", "]"
+          @containers.pop
+        when ":"
+          @expect = :value
+        when ","
+          @expect = @containers.last == :arr ? :value : :key
+        end
+      end
+
+      # A string just closed. After a VALUE, drop a newline so the next value
+      # (e.g. a write's `content` after its `path`) starts on its own line.
+      def close_string
+        @in_string = false
+        @line << "\n" if @is_value
+        @expect = @containers.last == :arr ? :value : :key
+      end
+
+      # Splits @line at its last newline: everything up to and including it is
+      # returned; the remainder stays buffered as the partial current line.
+      def take_complete_lines
+        idx = @line.rindex("\n")
+        return "" if idx.nil?
+
+        out = @line[0..idx]
+        @line = @line[(idx + 1)..] || +""
+        out
+      end
+    end
+  end
+end

data/lib/rubino/update_check.rb

@@ -191,9 +191,17 @@ module Rubino
       installed_gem_version(GEM_NAME) ? :gem : :source
     end
 
+    # The HIGHEST installed version of +name+ on disk, or nil when none is
+    # installed. Uses find_all_by_name (NOT find_by_name) because the running
+    # `rubino` process has its own gem version ACTIVATED — find_by_name returns
+    # that activated spec, so right after `gem update` pulls a newer gem it still
+    # reported the old version and `rubino update` wrongly said "already up to
+    # date". find_all_by_name isn't activation-filtered; taking the max sees the
+    # freshly-installed version (callers that need post-install freshness run
+    # Gem.refresh first — see Commands#update).
     def installed_gem_version(name)
-      Gem::Specification.find_by_name(name).version.to_s
-    rescue Gem::MissingSpecError, StandardError
+      Gem::Specification.find_all_by_name(name).map(&:version).max&.to_s
+    rescue StandardError
       nil
     end
 

data/lib/rubino/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Rubino
-  VERSION = "0.5.2.1"
+  VERSION = "0.5.2.2"
 
   # The ONE product tagline (#559). Both chrome surfaces that introduce rubino —
   # the `rubino --help` banner (CLI::Commands::TAGLINE) and the first-run chat

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubino-agent
 version: !ruby/object:Gem::Version
-  version: 0.5.2.1
+  version: 0.5.2.2
 platform: ruby
 authors:
 - Jhon Rojas
@@ -516,21 +516,25 @@ extensions:
 - ext/landlock/extconf.rb
 extra_rdoc_files: []
 files:
+- ".dockerignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".ruby-version"
-- AGENTS.md
 - CHANGELOG.md
 - CONTRIBUTING.md
+- Dockerfile
 - LICENSE
 - README.md
 - Rakefile
-- docs/agents.md
+- agent.md
 - docs/api/v1.md
 - docs/architecture.md
 - docs/commands.md
 - docs/configuration.md
+- docs/design/bg-shell-pty-port.md
+- docs/design/bg-shell-review-refinements.md
+- docs/design/bg-shell-ux.md
 - docs/getting-started.md
 - docs/jobs.md
 - docs/mcp.md
@@ -562,7 +566,11 @@ files:
 - lib/rubino/agent/prompts/compaction.txt
 - lib/rubino/agent/prompts/explore.txt
 - lib/rubino/agent/prompts/general.txt
+- lib/rubino/agent/prompts/memory_guidance.txt
 - lib/rubino/agent/prompts/plan.txt
+- lib/rubino/agent/prompts/tool_use_enforcement.txt
+- lib/rubino/agent/prompts/tool_use_enforcement_google.txt
+- lib/rubino/agent/prompts/tool_use_enforcement_openai.txt
 - lib/rubino/agent/response_validator.rb
 - lib/rubino/agent/runner.rb
 - lib/rubino/agent/tool_executor.rb
@@ -724,7 +732,6 @@ files:
 - lib/rubino/jobs/handlers/compact_session_job.rb
 - lib/rubino/jobs/handlers/distill_skill_job.rb
 - lib/rubino/jobs/handlers/extract_memory_job.rb
-- lib/rubino/jobs/handlers/summarize_session_job.rb
 - lib/rubino/jobs/queue.rb
 - lib/rubino/jobs/registry.rb
 - lib/rubino/jobs/runner.rb
@@ -860,6 +867,7 @@ files:
 - lib/rubino/tools/retrieve_output_tool.rb
 - lib/rubino/tools/ruby_tool.rb
 - lib/rubino/tools/session_search_tool.rb
+- lib/rubino/tools/shell_entry_adapter.rb
 - lib/rubino/tools/shell_input_tool.rb
 - lib/rubino/tools/shell_kill_tool.rb
 - lib/rubino/tools/shell_output_tool.rb
@@ -868,7 +876,6 @@ files:
 - lib/rubino/tools/shell_tool.rb
 - lib/rubino/tools/steer_tool.rb
 - lib/rubino/tools/subagent_probe.rb
-- lib/rubino/tools/summarize_file_tool.rb
 - lib/rubino/tools/task_result_tool.rb
 - lib/rubino/tools/task_stop_tool.rb
 - lib/rubino/tools/task_tool.rb
@@ -907,6 +914,7 @@ files:
 - lib/rubino/ui/stdout_proxy.rb
 - lib/rubino/ui/streaming_markdown.rb
 - lib/rubino/ui/subagent_cards.rb
+- lib/rubino/ui/tool_args_stream.rb
 - lib/rubino/ui/tool_label.rb
 - lib/rubino/update_check.rb
 - lib/rubino/util/atomic_file.rb
@@ -955,7 +963,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A lightweight Ruby coding and automation agent with persistent memory, sessions,
   and context compaction

data/AGENTS.md

@@ -1,97 +0,0 @@
-# AGENTS.md — rubino
-
-Onboarding for anyone (human or AI) working on this codebase.
-
-## Vision
-
-`rubino` is a **micro agent**: a small, self-contained Ruby gem that runs an LLM-driven coding/automation agent *on the machine where the work happens* — the user's PC or a VM. You drop it onto that machine and it works there, reachable over a clean HTTP API and a CLI. It executes conversation turns with tool calls, streams events, manages skills, and persists sessions/memory in a single SQLite file. It can be embedded as a library, run as a CLI, or run as a small service behind a REST gateway.
-
-It is a lightweight agent, **not a heavy framework**. We pick the few primitives that have real value and skip everything else. Scope discipline is part of the product.
-
-## Non-goals (explicit)
-
-These decisions are permanent. Reopen only with a written justification.
-
-- **No dual HTTP APIs.** One server, one versioned prefix (`/v1`). When we break, bump to `/v2`. Never aliases.
-- **No multi-tenant inside one process.** One instance = one workspace = one identity. Multi-tenant deployments run N instances.
-- **No dashboard / theme system / plugin hub.** The dashboard is whatever client consumes our API. We don't ship a UI server.
-- **No skill catalog bundled.** Skills are user-supplied directories. We don't ship a catalog.
-- **No compat layers.** Renamed something? Rename everywhere. Reshaped a response? Bump version.
-- **No auto-update endpoints.** Deploy = gem update + restart. Period.
-- **No backwards-compat shims, no _deprecated suffixes, no "legacy" anything.**
-
-## Architectural rules (load-bearing)
-
-These are load-bearing. When a PR violates them, it is the PR that gets redone.
-
-1. **One interface per concept.** One `LLM::Adapter`, one `Tools::Base`, one `Memory::Store`. Variants are subclasses, not parallels.
-2. **No PORO commands in `lib/`.** Domain logic on models/repositories; orchestration as class methods. No `app/services/Foo::DoThingCommand`.
-3. **No optional-magic params.** Signatures explicit. If long, refactor responsibilities, don't add `**opts`.
-4. **Schema-validated input at boundaries** (HTTP, CLI, MCP). Internals trust types.
-5. **Typed errors only.** `raise NotFoundError, "session"` not `raise "session not found"`.
-6. **Test contracts, not implementation.** Internals change without breaking tests, not vice versa.
-7. **Structured logging from day one.** JSON-line. No `puts`/`pp` outside the UI layer. Logger DI-injected.
-8. **No global singletons.** Config flows from the main loop into everything via constructor.
-9. **Handlers stay thin.** Endpoint >30 LOC → extract `Operation` class.
-10. **Less code, less bugs.** A refactor is good if it deletes net lines. Distrust preparatory abstractions (PORO/Result/custom errors before you need them).
-
-## Tech stack
-
-| Layer | Choice | Why |
-|---|---|---|
-| LLM | `ruby_llm ~> 1.0` (thin wrap) | One mature gem covering OpenAI/Anthropic/Gemini/Bedrock. We never call providers directly. |
-| MCP | `ruby_llm-mcp ~> 0.8` | Pairs natively with `ruby_llm`. |
-| HTTP server | `rack` + `puma` | Standard. WEBrick is gone. |
-| DB | `sequel` + `sqlite3` | One file, zero ops. Postgres later if multi-writer matters. |
-| Schema | `dry-schema` | Boundary validation. |
-| Scheduler | `rufus-scheduler` | Cron syntax, in-process. |
-| Config | `dry-configurable` | Already in use. |
-| CLI | `thor` | Already in use. |
-| Autoload | `zeitwerk` | Already in use. |
-| CLI UI | `tty-*` + `reline` | The interactive `rubino chat` prompt (history, completion, multi-line editing). |
-
-`ruby_llm` is the foundation. `LLM::RubyLLMAdapter` is a thin wrapper: it configures `RubyLLM`, delegates `chat`/`stream`/`model_info`, and exposes nothing the underlying gem can't already do. **If you find yourself adding business logic to the adapter, push it into the run loop instead.**
-
-## Layout
-
-```
-lib/rubino/
-  agent/         # run loop, lifecycle, multi-agent routing
-  api/           # HTTP gateway (Rack app, middleware, operations)
-  cli/           # thor commands
-  config/        # dry-configurable
-  context/       # compaction, prompt assembly
-  interaction/   # conversation lifecycle primitives
-  jobs/          # scheduler + worker (cron)
-  llm/           # ruby_llm adapter + model registry
-  mcp/           # MCP client + tool wrapper
-  memory/        # Memory::Store + extractors + retrievers
-  oauth/         # OAuth providers + connection storage
-  security/      # approval policy, sandboxing
-  session/       # repository + persistence
-  skills/        # SKILL.md loader
-  tools/         # built-in tools
-  ui/            # cli/null/api stub UIs
-```
-
-## Surfaces this project exposes
-
-- **HTTP API** (`/v1/*`) — the canonical interface. See `docs/api/v1.md`.
-- **CLI** — `rubino {setup,chat,prompt,server,config,memory,sessions,jobs,skills,tools,tls_cert,doctor,version,update}`.
-- **Library** — `require "rubino"; Rubino.run(...)`.
-
-The interactive CLI ships as part of `rubino chat`. Multi-agent routing, MCP, and plugin hooks are designed in but not fully wired yet.
-
-## Working on this codebase
-
-- Read `docs/architecture.md` for the bigger picture.
-- Read `docs/api/v1.md` for HTTP contract.
-- Read `docs/oauth-providers.md` for OAuth design.
-- Run `bundle exec rspec` before pushing.
-- Don't commit if rubocop fails.
-
-## Git/commit conventions
-
-- Conventional commits welcome but not required.
-- No AI attribution lines in commit messages.
-- Small commits over big ones. A commit that touches 30 files needs a justification.