rubino-agent 0.3.0

data/lib/rubino/commands/handlers/sessions.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/sessions` list/show/delete/picker surface plus the `/probe` and
+      # `/branch` REPL signals, extracted from Commands::Executor (batch B).
+      #
+      # No-arg = list recent + how to resume; arg = resolve and resume in place.
+      # Resuming returns a {resume_session_id:} signal the REPL acts on by
+      # rebuilding its runner on that session (history replays). Reuses
+      # Session::Repository#list and #find_by_id_or_title (which already raises
+      # AmbiguousSessionError on >1 match).
+      #
+      # The management verbs (#183) reuse the CLI subcommands' logic
+      # (CLI::SessionCommand.render / .destroy_with_confirm — ONE rendering and
+      # ONE delete flow for both surfaces):
+      #
+      #   /sessions                → list (picker on a TTY) + resume
+      #   /sessions --all          → list without the row cap
+      #   /sessions show <id>      → details, without switching into it
+      #   /sessions delete <id>    → delete (asks to confirm)
+      #   /sessions <id|title>     → resume
+      class Sessions
+        def initialize(ui:, runner:)
+          @ui = ui
+          @runner = runner
+        end
+
+        def handle_sessions(arguments)
+          tokens = arguments.to_s.strip.split(/\s+/)
+          all    = tokens.delete("--all") ? true : false
+          return list_sessions(all: all) if tokens.empty?
+
+          case tokens.first
+          when "show"   then session_verb(tokens[1..].join(" "), "show") { |s| CLI::SessionCommand.render(s, ui: @ui) }
+          when "delete" then session_verb(tokens[1..].join(" "), "delete") { |s| delete_session(s) }
+          else resume_session(tokens.join(" "))
+          end
+        end
+
+        # `/probe <text>` — the discoverable alias for the `? ` prefix. Bare
+        # `/probe` only teaches the prefix (the one-keystroke common case); with
+        # text, signal the REPL to run the ephemeral side-inference and discard.
+        def handle_probe(arguments)
+          text = arguments.to_s.strip
+          if text.empty?
+            @ui.info("Ask an ephemeral side-question that is NOT saved to this session.")
+            @ui.info("Tip: just start a line with '? ' — e.g.  ? is this lib MIT or GPL?")
+            return :handled
+          end
+
+          { probe: text }
+        end
+
+        # `/branch [name]` — fork the current session here into a NEW saved one
+        # and switch into it. The REPL holds the runner/session, so we just pass
+        # the optional title along on the branch signal.
+        def handle_branch(arguments)
+          title = arguments.to_s.strip
+          { branch: true, title: title.empty? ? nil : title }
+        end
+
+        private
+
+        # Resolves the id/title for a /sessions verb (same matcher resume uses,
+        # so short ids and title substrings work) and yields the session row;
+        # prints the usage/not-found/ambiguous error otherwise. Always :handled —
+        # the verbs never fall through to the unknown-command path (#34).
+        def session_verb(query, verb)
+          if query.nil? || query.empty?
+            @ui.info("Usage: /sessions #{verb} <id>")
+            return :handled
+          end
+
+          session = Session::Repository.new.find_by_id_or_title(query)
+          if session.nil?
+            @ui.error("no session matching #{query.inspect}.")
+            @ui.info("List them with /sessions")
+          else
+            yield session
+          end
+          :handled
+        rescue Rubino::AmbiguousSessionError => e
+          @ui.error(e.message)
+          :handled
+        end
+
+        # Deletes a session in-chat via the SAME confirm-and-destroy flow the
+        # `rubino sessions delete` CLI verb runs (#183). The session the live
+        # runner sits on is refused — deleting the history under the active
+        # runner would corrupt the running conversation; /new first.
+        def delete_session(session)
+          if @runner&.session&.dig(:id) == session[:id]
+            @ui.error("that is the ACTIVE session — start a new one first (/new), then delete it.")
+            return
+          end
+
+          CLI::SessionCommand.destroy_with_confirm(session, repo: Session::Repository.new, ui: @ui)
+        end
+
+        def list_sessions(all: false)
+          sessions = Session::Repository.new.list(limit: all ? nil : sessions_list_limit)
+          if sessions.empty?
+            @ui.info("No past sessions yet.")
+            return :handled
+          end
+
+          # ONE surface, not two (#40): on a real terminal the arrow-key picker
+          # IS the list (Enter resumes, Esc cancels — #73, letters filter), with
+          # Created/Status folded into each row, so the same sessions are never
+          # rendered twice (static table + picker). Off a TTY the static table +
+          # typed-shortcut fallback renders instead.
+          return sessions_table_fallback(sessions) unless interactive_terminal?
+
+          choices = sessions.map { |s| [session_choice_label(s), s[:id]] }
+          chosen  = @ui.select("Resume which session? (Esc to cancel)", choices)
+          if chosen
+            session = sessions.find { |s| s[:id] == chosen }
+            @ui.success(%(Resuming #{chosen[0..7]}  "#{session_title(session)}")) if session
+            return { resume_session_id: chosen }
+          end
+
+          @ui.info("Resume: /sessions <id|title>   ·   /sessions show|delete <id>")
+          :handled
+        end
+
+        # Static fallback for non-interactive callers (pipes / Null UI): the
+        # bordered table the picker replaces on a TTY. Leads with the identifying
+        # fields (ID, Title, Created) so a narrow-term card fallback scans well —
+        # the key field first, not buried (#84).
+        def sessions_table_fallback(sessions)
+          rows = sessions.map do |s|
+            [s[:id].to_s[0..7], session_title(s), s[:created_at].to_s, s[:status].to_s, s[:message_count].to_s]
+          end
+          @ui.table(headers: %w[ID Title Created Status Msgs], rows: rows)
+          @ui.info("Resume: /sessions <id|title>   ·   /sessions show|delete <id>")
+          :handled
+        end
+
+        # One picker row: short id + title + message count + recency (and status
+        # when not yet ended), so the highlighted entry is identifiable at a
+        # glance and the picker is a clean superset of the old static table (#40).
+        def session_choice_label(session)
+          id    = session[:id].to_s[0..7]
+          title = session_title(session)
+          msgs  = session[:message_count]
+          meta  = [
+            ("#{msgs} msg#{"s" if msgs != 1}" if msgs),
+            session_age(session),
+            (session[:status].to_s unless ["", "ended"].include?(session[:status].to_s))
+          ].compact.join(" · ")
+          meta.empty? ? "#{id}  #{title}" : "#{id}  #{title}  (#{meta})"
+        end
+
+        # "Created" humanized for the picker row — "5m ago" scans better than a
+        # raw ISO timestamp in a recency-ordered list (#40). nil when unparseable.
+        def session_age(session)
+          created = session[:created_at]
+          created = Time.parse(created.to_s) unless created.is_a?(Time)
+          "#{Rubino::Util::Duration.human_duration(Time.now - created)} ago"
+        rescue StandardError
+          nil
+        end
+
+        def resume_session(query)
+          session = Session::Repository.new.find_by_id_or_title(query)
+          if session.nil?
+            @ui.error("no session matching #{query.inspect}.")
+            @ui.info("List them with /sessions")
+            return :handled
+          end
+
+          @ui.success(%(Resuming #{session[:id][0..7]}  "#{session_title(session)}"))
+          { resume_session_id: session[:id] }
+        rescue Rubino::AmbiguousSessionError => e
+          @ui.error(e.message)
+          :handled
+        end
+
+        def session_title(session)
+          title = session[:title].to_s.strip
+          title.empty? ? "(untitled)" : title
+        end
+
+        # The bare-list row cap (#183): configurable (`sessions.list_limit`) and
+        # liftable per call with `/sessions --all` — no longer hardwired to 10.
+        def sessions_list_limit
+          limit = Rubino.configuration.dig("sessions", "list_limit").to_i
+          limit.positive? ? limit : 10
+        rescue StandardError
+          10
+        end
+
+        # True when the REPL owns a real interactive terminal (so the arrow-key
+        # picker makes sense). Off a TTY we render the static table fallback.
+        def interactive_terminal?
+          $stdin.respond_to?(:tty?) && $stdin.tty? && $stdout.respond_to?(:tty?) && $stdout.tty?
+        rescue StandardError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rubino/commands/handlers/skills.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/skills` list/activate/enable/disable surface, extracted from
+      # Commands::Executor (batch B).
+      #
+      # `/skills`                 → list (unchanged behavior).
+      # `/skills <name>`          → ACTIVATE that skill for the session (sticky).
+      #                             The name is validated against the registry; an
+      #                             unknown OR DISABLED name errors and leaves the
+      #                             active skill unchanged.
+      # `/skills none`            → CLEAR the active skill (also the `✗ none`
+      #                             picker entry, whose spliced label is
+      #                             normalized here).
+      # `/skills enable <name>`   → persistently re-enable a skill (#188) — the
+      # `/skills disable <name>`    same StateRepository write the HTTP API
+      #                             toggle and the `rubino skills` CLI verbs run
+      #                             (Skills::Toggle), affecting EVERY session,
+      #                             unlike the session-scoped activation.
+      #
+      # The active skill is stored in Rubino::ActiveSkill (a process-level slot,
+      # mirroring Rubino::Modes) so it survives across turns and is force-loaded
+      # into the system prompt each turn (Context::PromptAssembler).
+      class Skills
+        # The /skills toggle verbs (#188) — the same registry-validated
+        # StateRepository write the HTTP API and `rubino skills` CLI run.
+        TOGGLE_VERBS = %w[enable disable].freeze
+
+        def initialize(ui:)
+          @ui = ui
+        end
+
+        def handle_skills(arguments)
+          tokens = arguments.to_s.strip.split(/\s+/)
+          if TOGGLE_VERBS.include?(tokens.first.to_s.downcase)
+            toggle_skill(tokens[1], enabled: tokens.first.casecmp?("enable"))
+            return
+          end
+
+          arg = normalize_skill_arg(arguments)
+
+          return show_skills if arg.nil?
+
+          if clear_skill_arg?(arg)
+            previous = Rubino::ActiveSkill.current
+            Rubino::ActiveSkill.clear
+            if previous
+              @ui.success("Cleared active skill (was: #{previous}).")
+            else
+              @ui.info("No active skill.")
+            end
+            return
+          end
+
+          # Trust-aligned discovery (#63): activate only skills the assembler
+          # will actually pin — in an untrusted cwd a project-local skill is
+          # refused (with a reason) instead of chip-active-but-not-injected.
+          registry = Rubino::Skills::Registry.trusted
+          skill = registry.find(arg)
+          unless skill
+            if Rubino::Skills::Registry.new.find(arg)
+              @ui.error("skill #{arg} is in this directory's .rubino/skills, but the directory " \
+                        "isn't trusted — its SKILL.md would not be loaded, so it can't be activated")
+            else
+              @ui.error("unknown skill: #{arg}")
+              available = registry.names
+              @ui.info("Available: #{available.join(", ")}") unless available.empty?
+            end
+            return
+          end
+
+          # A disabled skill is EXCLUDED from activation (#188): the assembler
+          # refuses to inject it (active_skill_block checks enabled?), so pinning
+          # it would show an active chip with no effect.
+          unless registry.enabled?(skill.name)
+            @ui.error("skill #{skill.name} is disabled — /skills enable #{skill.name} to use it")
+            return
+          end
+
+          Rubino::ActiveSkill.set(skill.name)
+          @ui.success("Active skill: #{skill.name} (loaded into context for this session).")
+        end
+
+        private
+
+        # `/skills enable|disable <name>` (#188) — the missing human surface for
+        # the StateRepository toggle (previously HTTP-API-only). Persisted, so it
+        # affects the Level-1 index of every session until toggled back.
+        def toggle_skill(name, enabled:)
+          verb = enabled ? "enable" : "disable"
+          if name.to_s.strip.empty?
+            @ui.info("Usage: /skills #{verb} <name>")
+            return
+          end
+
+          registry = Rubino::Skills::Registry.trusted
+          unless Rubino::Skills::Toggle.set(name, enabled: enabled, registry: registry)
+            @ui.error("unknown skill: #{name}")
+            available = registry.names
+            @ui.info("Available: #{available.join(", ")}") unless available.empty?
+            return
+          end
+
+          if enabled
+            @ui.success("Enabled skill: #{name} (back in the skills index for every session).")
+          else
+            clear_disabled_active_skill(name)
+            @ui.success("Disabled skill: #{name} (out of the index for every session; " \
+                        "/skills enable #{name} to restore).")
+          end
+        end
+
+        # Disabling the skill that is currently PINNED active would leave a lying
+        # chip — the assembler silently drops a disabled active skill — so the
+        # pin is cleared with a note instead.
+        def clear_disabled_active_skill(name)
+          return unless Rubino::ActiveSkill.current == name
+
+          Rubino::ActiveSkill.clear
+          @ui.info("(it was the active skill — pin cleared)")
+        end
+
+        # The single argument to `/skills`, trimmed; nil when no argument was
+        # given (bare `/skills` → list). The picker splices the `✗ none` label, so
+        # the leading `✗ ` marker is stripped here to recover the bare token.
+        def normalize_skill_arg(arguments)
+          raw = arguments.to_s.strip.sub(/\A✗\s+/, "")
+          # Only the FIRST token is the skill name (skill names are single tokens).
+          token = raw.split(/\s+/).first
+          token unless token.nil? || token.empty?
+        end
+
+        # True when the argument means "clear the active skill" (the `none`
+        # sentinel, case-insensitive — the `✗ ` marker was already stripped).
+        def clear_skill_arg?(arg)
+          arg.casecmp?(Rubino::ActiveSkill::NONE)
+        end
+
+        def show_skills
+          registry = Rubino::Skills::Registry.trusted
+          skills = registry.all
+          if skills.empty?
+            @ui.info("No skills found.")
+            @ui.info("Add .md files to .rubino/skills/ to create skills.")
+          else
+            active = Rubino::ActiveSkill.current
+            skills.each do |skill|
+              status = registry.enabled?(skill.name) ? "" : " (disabled)"
+              status += " (active)" if active && active == skill.name
+              head   = "  #{skill.name}#{status} - "
+              # Word-wrap the description so a long one breaks on spaces instead of
+              # being hard-wrapped mid-word by the terminal at the right edge
+              # (B8 — "officia\nl"). Continuation lines hang-indent under the
+              # description so the list stays readable.
+              wrap_skill_line(head, skill.description.to_s).each { |line| @ui.info(line) }
+            end
+          end
+        end
+
+        # Wraps "<head><description>" to the terminal width, breaking only on
+        # whitespace, with continuation lines indented to the description column.
+        def wrap_skill_line(head, description)
+          width = terminal_width
+          indent = " " * head.length
+          avail  = [width - head.length, 20].max
+
+          lines = []
+          current = +""
+          description.split(/\s+/).each do |word|
+            candidate = current.empty? ? word : "#{current} #{word}"
+            if candidate.length > avail && !current.empty?
+              lines << current
+              current = word.dup
+            else
+              current = candidate
+            end
+          end
+          lines << current unless current.empty?
+          lines = [""] if lines.empty?
+
+          lines.each_with_index.map { |line, i| (i.zero? ? head : indent) + line }
+        end
+
+        def terminal_width
+          cols = IO.console&.winsize&.last
+          cols&.positive? ? cols : 80
+        rescue StandardError
+          80
+        end
+      end
+    end
+  end
+end

data/lib/rubino/commands/handlers/status.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/status` at-a-glance state panel, extracted from Commands::Executor
+      # (batch B). Assembles the model/mode/session lines plus approval policy,
+      # provider/connection, and the tool/mcp/memory/skills rosters over the same
+      # services (Modes, Session::Repository, Memory backend, BackgroundTasks,
+      # Skills::Registry). A plain collaborator given the live `ui`/`runner`.
+      class Status
+        def initialize(ui:, runner:)
+          @ui = ui
+          @runner = runner
+        end
+
+        # Labels dim, values plain, cyan only on the actionable pointers (P8).
+        def show_status
+          @ui.separator
+          @ui.panel_line("model", status_model)
+          @ui.panel_line("provider", status_provider_line)
+          @ui.panel_line("mode", "#{Rubino::Modes.current} — #{Rubino::Modes.description}")
+          @ui.panel_line("display", status_display_line, pointer: "(use /reasoning · /think)")
+          @ui.panel_line("approvals", status_approvals_line)
+          @ui.panel_line("session", status_session_line)
+          @ui.panel_line("tools", status_tools_line)
+          # MCP only when servers are configured (#182/#186) — a non-MCP user's
+          # /status stays exactly as before, and MCP tools stop being invisibly
+          # mixed into the truncated tools line as the only trace of MCP.
+          @ui.panel_line("mcp", status_mcp_line, pointer: "(use /mcp)") if Rubino::MCP.enabled?
+          if (dirs = status_dirs_line)
+            @ui.panel_line("dirs", dirs, pointer: "(use /dirs)")
+          end
+          @ui.panel_line("memory", status_memory_line, pointer: "(use /memory)")
+          @ui.panel_line("skills", status_skills_line, pointer: "(use /skills)")
+          @ui.panel_line("background", status_background_line, pointer: "(use /agents)")
+          if (jobs = status_jobs_line)
+            @ui.panel_line("jobs", jobs, pointer: "(use /jobs)")
+          end
+          @ui.separator
+        end
+
+        private
+
+        # The persisted display prefs (#186): /reasoning and /think write config
+        # but were invisible — not in the chip, not in /status.
+        def status_display_line
+          mode   = Rubino::Config::ReasoningPrefs.mode(Rubino.configuration)
+          effort = Rubino::Config::ReasoningPrefs.effort(Rubino.configuration) ||
+                   Rubino::Config::ReasoningPrefs::DEFAULT_EFFORT
+          "reasoning: #{mode} · effort: #{effort}"
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        # Workspace roots + trust (#186) — trust is the #1 "why are my
+        # skills/AGENTS.md not loading" confusion. Only earns a line when there
+        # is something to say (>1 root or any untrusted); nil otherwise.
+        def status_dirs_line
+          roots     = Rubino::Workspace.canonical_roots
+          untrusted = roots.count { |d| !Rubino::Trust.trusted?(d) }
+          return nil if roots.size <= 1 && untrusted.zero?
+
+          line = "#{roots.size} root#{"s" if roots.size != 1}"
+          untrusted.positive? ? "#{line} · #{untrusted} untrusted (context/skills withheld)" : line
+        rescue StandardError
+          nil
+        end
+
+        # The persistent jobs queue (#186) — distinct from the in-process
+        # `background` subagents line. Only earns a line when nonzero; nil (no
+        # line) when the queue is empty or unreadable.
+        def status_jobs_line
+          queue   = Rubino::Jobs::Queue.new
+          pending = queue.pending_count
+          failed  = queue.failed_count
+          return nil unless pending.positive? || failed.positive?
+
+          [("#{pending} pending" if pending.positive?),
+           ("#{failed} failed" if failed.positive?)].compact.join(" · ")
+        rescue StandardError
+          nil
+        end
+
+        def status_model
+          @runner&.session&.dig(:model) ||
+            (@runner.respond_to?(:model_id) ? @runner.model_id : nil) ||
+            Rubino.configuration.model_default
+        end
+
+        # The configured provider — the "what am I talking to" line a status
+        # check wants. We report the configured target, not a live probe (a
+        # health round-trip would make /status slow and flaky).
+        def status_provider_line
+          Rubino.configuration.model_provider || "(default)"
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        # One-line approval-policy summary so a newcomer knows what will prompt.
+        # Mode is authoritative: yolo skips every approval, plan filters mutating
+        # tools out entirely; otherwise approvals come from config.
+        def status_approvals_line
+          case Rubino::Modes.current
+          when :yolo then "skipped (yolo mode — nothing prompts)"
+          when :plan then "read-only mode — no edits/shell to approve"
+          else            "from config (mutating commands prompt)"
+          end
+        end
+
+        # A compact roster of the tools the agent can actually use right now
+        # (mode filters the registry), so /status answers "what can it DO".
+        def status_tools_line
+          names = Tools::Registry.instance.enabled_tools.map(&:name).sort
+          return "(none)" if names.empty?
+
+          truncate(names.join(", "), 64)
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        # `2 servers · 1 reachable · 14 tools` — reads the LIVE booted manager
+        # (no client → 0 reachable), never re-spawns servers.
+        def status_mcp_line
+          servers   = mcp_servers_config.size
+          reachable = mcp_health.count { |h| h[:alive] }
+          tools     = Tools::Registry.all.count { |t| t.is_a?(Rubino::MCP::MCPToolWrapper) }
+          "#{servers} server#{"s" if servers != 1} · #{reachable} reachable · #{tools} tool#{"s" if tools != 1}"
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        def status_session_line
+          session = @runner&.session
+          return "(none)" unless session
+
+          id    = session[:id].to_s[0..7]
+          title = session[:title].to_s.strip
+          title = title.empty? ? "(untitled)" : %("#{title}")
+          msgs  = status_message_count(session)
+          "#{id}  #{title}#{" · #{msgs} msgs" if msgs}"
+        end
+
+        # The session's message count, read LIVE from the message store. The
+        # in-memory session hash's :message_count is a boot-time snapshot the
+        # streaming path never refreshes, so /status reported a permanent
+        # "0 msgs" while the DB had every turn (#159). Counting the persisted
+        # rows also matches the "Loaded N prior messages" resume banner.
+        def status_message_count(session)
+          Session::Store.new.count(session[:id])
+        rescue StandardError
+          session[:message_count]
+        end
+
+        # /status must count facts on the ACTIVE backend — the same store /memory
+        # and the `rubino memory` CLI read via Memory::Backends.build — not the
+        # legacy `:memories` table Memory::Store is hardwired to (#83).
+        def status_memory_line
+          backend = Rubino.configuration.dig("memory", "backend") || Rubino::Memory::Backends::DEFAULT_NAME
+          "backend: #{backend} · #{memory_backend.count} facts"
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        def status_skills_line
+          registry = Rubino::Skills::Registry.trusted
+          all      = registry.all
+          enabled  = all.count { |s| registry.enabled?(s.name) }
+          line     = "#{all.size} available, #{enabled} enabled"
+          # WHICH skill is pinned (#186) — the chip shows it but the canonical
+          # state dump omitted it.
+          active = Rubino::ActiveSkill.current
+          active ? "#{line} · active: #{active}" : line
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        def status_background_line
+          entries = Tools::BackgroundTasks.instance.list
+          running = entries.count { |e| e.status == :running }
+          ids     = entries.first(3).map(&:id).join(", ")
+          line    = "#{running} running · #{entries.size} total"
+          ids.empty? ? line : "#{line} (#{ids})"
+        rescue StandardError
+          "(unavailable)"
+        end
+
+        # Resolve the *configured* memory backend (default: sqlite tiny-Zep) for
+        # the fact count — the same store the agent loop and /memory read.
+        def memory_backend
+          @memory_backend ||= Rubino::Memory::Backends.build
+        end
+
+        # The configured mcp.servers block (name => config), {} when absent.
+        def mcp_servers_config
+          Rubino.configuration.dig("mcp", "servers") || {}
+        end
+
+        # Live reachability from the booted manager; [] when MCP never booted.
+        def mcp_health
+          Rubino::MCP.manager&.health_check || []
+        end
+
+        def truncate(text, max)
+          s = text.to_s.gsub(/\s+/, " ").strip
+          s.length > max ? "#{s[0, max - 1]}…" : s
+        end
+      end
+    end
+  end
+end