rcas 0.2.0

data/lib/rcas/chat/assistant.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RCAS
+  module Chat
+    # The conversation with Claude. Streams replies, lets the SDK's tool
+    # runner execute rcas_eval calls, and keeps the message history.
+    class Assistant
+      DEFAULT_MODEL = ENV.fetch("RCAS_MODEL", "claude-opus-5")
+      FALLBACK_MODEL = "claude-opus-4-8"
+      FALLBACK_BETA = "server-side-fallback-2026-06-01"
+
+      # USD per million input / output tokens, for /cost.
+      PRICES = {
+        "claude-opus-5" => [5.0, 25.0], "claude-opus-4-8" => [5.0, 25.0], "claude-opus-4-7" => [5.0, 25.0],
+        "claude-fable-5-1" => [10.0, 50.0], "claude-fable-5" => [10.0, 50.0],
+        "claude-sonnet-5" => [2.0, 10.0], "claude-sonnet-4-6" => [3.0, 15.0], "claude-haiku-4-5" => [1.0, 5.0]
+      }.freeze
+
+      SYSTEM = <<~PROMPT
+        You are the assistant inside rcas-chat, a terminal front end for rcas, a small computer algebra system written in Ruby. The user types Ruby directly or asks questions in plain language. You answer by computing with the rcas_eval tool, which evaluates Ruby in the user's live session: their variables and assumptions are visible to you and whatever you define persists.
+
+        How to work:
+        - Compute with rcas_eval rather than doing algebra by hand, and check claims by evaluating them.
+        - The terminal typesets results you display with show: true. Use show: true for the final result(s) the user asked for, and do not retype those expressions in your reply.
+        - Keep replies short: the result, then at most a sentence or two of explanation or a hint about what else the user could ask. No headings, no bullet lists unless the user asks for a comparison.
+        - When a call fails, read the error, fix the code and retry. If rcas cannot do something, say so plainly and suggest the nearest thing it can do.
+        - Write ordinary Ruby: ** is power, 1/2r is the rational one half, a bare lowercase name or :x is an indeterminate (a symbolic unknown). Use assume(x: ZZ) to declare domains when a computation needs them.
+
+        rcas reference:
+        - Expressions: Symbols are indeterminates; + - * / ** build trees exactly as written; nothing is rewritten until asked. e.simplify, e.expand, e.factor, e.diff(x [, n]), e.integrate(x), e.subs(x: y + 1) or e.subs(pattern => replacement), e.call(x: 3) (a number when fully bound), e.evalf(x: 1.5), e.variables, e.domain, e.to_poly([ring]), e.to_sexp, e.to_latex. Functions: sin cos tan atan sinh cosh exp log sqrt; log is the natural logarithm. Numbers stay exact (Integer/Rational).
+        - Number sets: NN ZZ QQ RR CC (include?, ===, <, <=). Domains of variables: x.in(ZZ), assume(x: ZZ, y: RR), assumptions, forget; (x / 2).domain infers the smallest set.
+        - Polynomial rings: ZZ[x], QQ[x, y], RR[t]; R.(expr) converts to an RCAS::Polynomial. f + g, f * g, f**n, f / g (exact), f.divmod(g), f % g (univariate), f.gcd(g), f.lcm(g), f.xgcd(g) => [g, s, t], f.degree([var]), f.coefficients (univariate), f.coeff(*exps), f.leading_coefficient, f.derivative([var]), f.integrate([var]), f.factor => RCAS::Factorization (unit, factors as [poly, multiplicity], expand, to_expr), f.irreducible?, f.squarefree_decomposition, f.roots (rational roots), f.resultant(g [, var]), f.discriminant([var]), f.coprime?(g), f.content, f.primitive_part, f.monic, f.to_expr, f.ring. Factorization is exact over ZZ and QQ only. (x**2 - y**2).factor works straight on expressions. R.fraction_field is Frac(R).
+        - Vectors and matrices: V = QQ**3; v = V[1, 2, 3]; v + w, 2 * v, v / 2, v * w (dot), v.cross(w), v.norm. A = QQ**[2, 2]; a = A[[1, 2], [3, 4]]; also matrix([[1, 2], [3, 4]]), matrix(RR, rows), vector(1, 2), vector(QQ, 1, 2). a.det, a.trace, a.rank, a.inverse, a.transpose, a**n, a * b, a * v, a.charpoly(:l), a.solve([5, 6]), a.rref, a.kernel, a.identity?, a.symmetric?, a.adjugate, a.cofactor(i, j), A.identity, A.zero. Symbolic entries need declared variables (assume(t: RR)). Numeric matrices over ZZ/QQ are exact.
+        - Display: obj.to_latex gives LaTeX; show(obj) typesets it in the terminal.
+      PROMPT
+
+      attr_accessor :model, :fallbacks, :on_tool_call
+      attr_accessor :messages
+      attr_reader :usage, :ui
+
+      def initialize(workspace, ui, model: DEFAULT_MODEL, client: nil, fallbacks: ENV["RCAS_FALLBACKS"] != "0", runner_factory: nil)
+        @workspace = workspace
+        @ui = ui
+        @model = model
+        @client = client
+        @fallbacks = fallbacks
+        @runner_factory = runner_factory
+        @messages = []
+        @usage = Hash.new(0)
+        # a scripted runner (the tests) needs the tool as much as real credentials do
+        Chat.load_anthropic if runner_factory || self.class.credentials?
+        return unless defined?(EvalTool)
+        @tool = EvalTool.new(workspace, ui)
+        @tool.on_call = ->(code, result) { @on_tool_call&.call(code, result) }
+      end
+
+      # Loads the gem on first use (Chat.load_anthropic): a session nobody
+      # asks Claude in never loads it.
+      def self.gem_available? = Chat.load_anthropic
+
+      # Credentials are resolved by the SDK (ANTHROPIC_API_KEY, or a profile
+      # from `ant auth login`); we only know for sure once a request is made.
+      def available?
+        return true if @runner_factory || @client
+        self.class.configured?
+      end
+
+      # Gem installed and credentials present: only then does the chat mention
+      # Claude at all. The credentials are asked first, so that without them
+      # the gem is never loaded.
+      def self.configured? = credentials? && gem_available?
+
+      def self.credentials?
+        !ENV["ANTHROPIC_API_KEY"].to_s.empty? || !ENV["ANTHROPIC_AUTH_TOKEN"].to_s.empty? ||
+          File.directory?(File.join(Dir.home, ".config", "anthropic"))
+      end
+
+      def client = @client ||= Anthropic::Client.new
+
+      def reset = @messages = []
+
+      def params
+        p = {
+          model: model,
+          max_tokens: 16_000,
+          system_: [{ type: "text", text: SYSTEM, cache_control: { type: "ephemeral" } }],
+          tools: [@tool],
+          messages: @messages,
+          max_iterations: 16
+        }
+        if fallbacks && model.start_with?("claude-opus-5", "claude-fable")
+          p[:betas] = [FALLBACK_BETA]
+          p[:fallbacks] = [{ model: FALLBACK_MODEL }]
+        end
+        p
+      end
+
+      # Ask Claude; streams the reply and runs any tool calls. Returns the
+      # final reply text (also printed), or nil when interrupted.
+      def ask(text, note: nil)
+        raise Error, "the anthropic gem is not installed: gem install anthropic" unless self.class.gem_available?
+        snapshot = @messages.dup
+        prompt = text.dup
+        prompt << "\n\n(This did not evaluate as Ruby: #{note})" if note
+        prompt << context
+        @messages << { role: :user, content: prompt }
+
+        last = nil
+        runner = @runner_factory ? @runner_factory.call(params) : client.beta.messages.tool_runner(params)
+        @ui.assistant_start
+        @ui.busy_start("thinking")
+        runner.each_streaming do |stream|
+          stream.each { |event| handle_event(event) }
+          last = stream.accumulated_message
+          record_usage(last)
+        end
+        @ui.assistant_end
+        history = runner.params[:messages].to_a
+        history += [{ role: :assistant, content: last.content }] if last && history.last&.[](:role) != :assistant
+        @messages = history
+        note_stop_reason(last) if last
+        last ? last.content.select { |b| b.type == :text }.map(&:text).join : ""
+      rescue Interrupt
+        @ui.assistant_end
+        @ui.info("(interrupted)")
+        @messages = snapshot
+        nil
+      rescue StandardError => e
+        @ui.assistant_end
+        @messages = snapshot
+        raise Error, describe(e)
+      end
+
+      def handle_event(event)
+        @ui.assistant_text(event.text) if event.type == :text
+      end
+
+      def note_stop_reason(message)
+        case message.stop_reason
+        when :refusal
+          details = message.respond_to?(:stop_details) && message.stop_details ? " (#{message.stop_details.category})" : ""
+          @ui.info("Claude declined to answer this#{details}.")
+        when :max_tokens
+          @ui.info("(reply cut off at the token limit)")
+        end
+      end
+
+      def record_usage(message)
+        u = message.usage
+        return unless u
+        @usage[:input] += u.input_tokens.to_i
+        @usage[:output] += u.output_tokens.to_i
+        @usage[:cache_read] += u.cache_read_input_tokens.to_i if u.respond_to?(:cache_read_input_tokens)
+        @usage[:cache_write] += u.cache_creation_input_tokens.to_i if u.respond_to?(:cache_creation_input_tokens)
+        @usage[:requests] += 1
+      end
+
+      def cost
+        input, output = PRICES[model] || PRICES.find { |k, _| model.start_with?(k) }&.last
+        lines = ["requests: #{@usage[:requests]}   input tokens: #{@usage[:input]} (cache read #{@usage[:cache_read]}, cache write #{@usage[:cache_write]})   output tokens: #{@usage[:output]}"]
+        if input
+          usd = (@usage[:input] * input + @usage[:output] * output) / 1_000_000.0
+          lines << format("approx. list price for %s: $%.4f (cache reads are billed lower)", model, usd)
+        end
+        lines.join("\n")
+      end
+
+      # What the session currently holds, appended to each question.
+      def context
+        locals = @workspace.locals.reject { |_, v| v.is_a?(Symbol) }.map { |k, v| "#{k} = #{clip(v.to_s.gsub("\n", ' '))}" }
+        symbols = @workspace.locals.select { |k, v| v.is_a?(Symbol) && v == k }.keys
+        assumptions = RCAS.assumptions.values.flatten.map(&:to_s)
+        parts = []
+        parts << "variables: #{symbols.join(', ')}" unless symbols.empty?
+        parts << "locals: #{locals.join('; ')}" unless locals.empty?
+        parts << "assumptions: #{assumptions.join(', ')}" unless assumptions.empty?
+        parts.empty? ? "" : "\n\n[session #{parts.join(' | ')}]"
+      end
+
+      def clip(text, max = 120) = text.size > max ? "#{text[0, max]}…" : text
+
+      def describe(error)
+        return "#{error.class}: #{error.message}" unless defined?(Anthropic::Errors)
+        case error
+        when Anthropic::Errors::AuthenticationError
+          "no valid Anthropic credentials. Set ANTHROPIC_API_KEY (or run `ant auth login`) and try again."
+        when Anthropic::Errors::RateLimitError
+          "rate limited by the API; wait a moment and try again."
+        when Anthropic::Errors::APIStatusError
+          "API error #{error.status} (#{error.type}): #{error.message.lines.first&.strip}"
+        when Anthropic::Errors::APIConnectionError
+          "could not reach the Anthropic API: #{error.message.lines.first&.strip}"
+        else
+          "#{error.class}: #{error.message.lines.first&.strip}"
+        end
+      end
+    end
+  end
+end

data/lib/rcas/chat/picker.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "stringio"
+
+module RCAS
+  module Chat
+    # An interactive list of saved sessions, in the style of Claude Code's
+    # /resume: arrow keys move, typing filters, Enter picks, Esc cancels.
+    # Without a terminal it degrades to a numbered list read from stdin.
+    class Picker
+      UP    = ["\e[A", "\eOA", "\x10"].freeze # up arrow, Ctrl-P
+      DOWN  = ["\e[B", "\eOB", "\x0E"].freeze # down arrow, Ctrl-N
+      ENTER = ["\r", "\n"].freeze
+      QUIT  = ["\e", "\x03", "\x04"].freeze   # Esc, Ctrl-C, Ctrl-D
+      BACK  = ["\x7F", "\b"].freeze
+
+      attr_reader :sessions
+
+      def initialize(sessions, input: $stdin, output: $stdout, title: "Resume a session")
+        @sessions = sessions
+        @input = input
+        @output = output
+        @title = title
+        @query = +""
+        @selected = 0
+        @drawn = 0
+      end
+
+      # => the chosen Session, or nil
+      def run
+        return nil if @sessions.empty?
+        return fallback unless tty?
+        @output.print "\e[?25l"
+        @input.raw(intr: false) do
+          loop do
+            draw
+            case (key = read_key)
+            when *QUIT then return nil
+            when *ENTER then return matches[@selected]
+            when *UP then @selected -= 1
+            when *DOWN then @selected += 1
+            when *BACK then @query.chop!
+            else @query << key if key && key.match?(/\A[[:print:]]\z/)
+            end
+            @selected = @selected.clamp(0, [matches.size - 1, 0].max)
+          end
+        end
+      ensure
+        clear
+        @output.print "\e[?25h"
+        @output.flush
+      end
+
+      def matches
+        return @sessions if @query.empty?
+        q = @query.downcase
+        @sessions.select { |s| [s.title, s.first_input, s.id].compact.any? { |t| t.downcase.include?(q) } }
+      end
+
+      # ---- drawing ----------------------------------------------------------
+
+      def draw
+        list = matches
+        visible = visible_rows
+        first = [[@selected - visible + 1, 0].max, [list.size - visible, 0].max].min
+        lines = [Style.bold(@title) + Style.dim("  ↑/↓ move · Enter select · Esc cancel · type to filter")]
+        lines << ""
+        if list.empty?
+          lines << Style.dim("  no session matches #{@query.inspect}")
+        else
+          list[first, visible].each_with_index do |session, i|
+            index = first + i
+            lines.concat(row(session, index, index == @selected))
+          end
+          lines << Style.dim("  … #{list.size - first - visible} more") if first + visible < list.size
+        end
+        lines << ""
+        lines << (@query.empty? ? Style.dim("  filter: type to search") : "  #{Style.dim('filter:')} #{@query}▌")
+        redraw(lines)
+      end
+
+      def row(session, index, selected)
+        pointer = selected ? Style.cyan("❯") : " "
+        head = "#{pointer} #{Style.dim((index + 1).to_s.rjust(2) + '.')} #{session.relative_time.ljust(15)} #{"#{session.turns} inputs".ljust(11)} #{Style.bold(session.name)}"
+        head = Style.paint(Style.strip(head), :cyan) if selected
+        preview = session.first_input
+        lines = [head]
+        lines << "     #{Style.dim(preview)}" if preview && preview != session.title
+        lines
+      end
+
+      def redraw(lines)
+        width = columns - 1
+        @output.print "\e[#{@drawn}A" if @drawn.positive?
+        # The terminal is in raw mode while the picker runs, so a bare newline
+        # would not return to column 0: start each row with \r and end it with \r\n.
+        lines.each { |l| @output.print "\r\e[2K#{truncate(l, width)}\r\n" }
+        # The list may have shrunk: blank any rows left from the last frame.
+        (@drawn - lines.size).clamp(0, 100).times { @output.print "\r\e[2K\r\n" }
+        extra = [@drawn - lines.size, 0].max
+        @output.print "\e[#{extra}A" if extra.positive?
+        @drawn = lines.size
+        @output.flush
+      end
+
+      def clear
+        return unless @drawn.positive?
+        @output.print "\r\e[#{@drawn}A\e[J"
+        @drawn = 0
+      end
+
+      def truncate(line, width)
+        return line if Style.strip(line).size <= width
+        "#{Style.strip(line)[0, [width - 1, 0].max]}…"
+      end
+
+      def visible_rows
+        rows = @output.respond_to?(:winsize) ? @output.winsize[0] : 24
+        ((rows - 6) / 2).clamp(3, 10)
+      rescue StandardError
+        6
+      end
+
+      def columns
+        cols = @output.respond_to?(:winsize) ? @output.winsize[1] : 0
+        cols.positive? ? cols : 100
+      rescue StandardError
+        100
+      end
+
+      # ---- input ------------------------------------------------------------
+
+      def tty? = [@input, @output].all? { |io| io.respond_to?(:tty?) && io.tty? } && @input.respond_to?(:raw)
+
+      # One key: a character, or a whole escape sequence (Esc, then "[" or
+      # "O", then the final letter). A lone Esc is one that nothing follows.
+      def read_key
+        key = @input.getc
+        return key if key.nil? || key != "\e" || !pending_input?
+        second = @input.getc or return key
+        key += second
+        key += @input.getc.to_s if ["[", "O"].include?(second)
+        key
+      end
+
+      def pending_input?
+        return !@input.eof? if @input.is_a?(StringIO)
+        IO.select([@input], nil, nil, 0.05) ? true : false
+      end
+
+      # Numbered list on a plain stream.
+      def fallback
+        @output.puts @title
+        @sessions.first(20).each_with_index { |s, i| @output.puts "  #{(i + 1).to_s.rjust(2)}  #{s.summary}" }
+        @output.print "Resume which? [1] "
+        @output.flush
+        answer = @input.gets.to_s.strip
+        answer = "1" if answer.empty?
+        Session.find(answer, among: @sessions)
+      end
+    end
+  end
+end