rubyn-code 0.1.0

data/lib/rubyn_code/observability/usage_reporter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubynCode
+  module Observability
+    # Generates human-readable cost and usage summaries from recorded cost data.
+    class UsageReporter
+      TABLE_NAME = BudgetEnforcer::TABLE_NAME
+
+      # @param db [DB::Connection] database connection
+      # @param formatter [Output::Formatter] output formatter for colorized text
+      def initialize(db, formatter:)
+        @db        = db
+        @formatter = formatter
+      end
+
+      # Returns a formatted summary of cost and usage for a given session.
+      #
+      # @param session_id [String]
+      # @return [String] multi-line formatted summary
+      def session_summary(session_id)
+        rows = @db.query(
+          "SELECT model, input_tokens, output_tokens, cost_usd FROM #{TABLE_NAME} WHERE session_id = ?",
+          [session_id]
+        ).to_a
+
+        return "No usage data for session #{session_id}." if rows.empty?
+
+        total_input   = rows.sum { |r| fetch_int(r, "input_tokens") }
+        total_output  = rows.sum { |r| fetch_int(r, "output_tokens") }
+        total_cost    = rows.sum { |r| fetch_float(r, "cost_usd") }
+        turns         = rows.size
+        avg_cost      = turns.positive? ? total_cost / turns : 0.0
+
+        lines = [
+          header("Session Summary"),
+          field("Session", session_id),
+          field("Turns", turns.to_s),
+          field("Input tokens", format_number(total_input)),
+          field("Output tokens", format_number(total_output)),
+          field("Total tokens", format_number(total_input + total_output)),
+          field("Total cost", format_usd(total_cost)),
+          field("Avg cost/turn", format_usd(avg_cost))
+        ]
+
+        lines.join("\n")
+      end
+
+      # Returns a formatted summary of today's total cost across all sessions.
+      #
+      # @return [String] multi-line formatted summary
+      def daily_summary
+        today = Time.now.utc.strftime("%Y-%m-%d")
+        rows = @db.query(
+          "SELECT session_id, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, " \
+          "SUM(cost_usd) AS cost_usd, COUNT(*) AS turns FROM #{TABLE_NAME} " \
+          "WHERE created_at >= ? GROUP BY session_id",
+          ["#{today}T00:00:00Z"]
+        ).to_a
+
+        return "No usage data for today." if rows.empty?
+
+        total_input  = rows.sum { |r| fetch_int(r, "input_tokens") }
+        total_output = rows.sum { |r| fetch_int(r, "output_tokens") }
+        total_cost   = rows.sum { |r| fetch_float(r, "cost_usd") }
+        total_turns  = rows.sum { |r| fetch_int(r, "turns") }
+        sessions     = rows.size
+
+        lines = [
+          header("Daily Summary (#{today})"),
+          field("Sessions", sessions.to_s),
+          field("Total turns", total_turns.to_s),
+          field("Input tokens", format_number(total_input)),
+          field("Output tokens", format_number(total_output)),
+          field("Total cost", format_usd(total_cost))
+        ]
+
+        lines.join("\n")
+      end
+
+      # Returns a cost breakdown by model for a given session.
+      #
+      # @param session_id [String]
+      # @return [String] multi-line formatted breakdown
+      def model_breakdown(session_id)
+        rows = @db.query(
+          "SELECT model, SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens, " \
+          "SUM(cost_usd) AS cost_usd, COUNT(*) AS calls FROM #{TABLE_NAME} " \
+          "WHERE session_id = ? GROUP BY model ORDER BY cost_usd DESC",
+          [session_id]
+        ).to_a
+
+        return "No usage data for session #{session_id}." if rows.empty?
+
+        lines = [header("Cost by Model")]
+
+        rows.each do |row|
+          model   = row["model"] || row[:model]
+          cost    = fetch_float(row, "cost_usd")
+          calls   = fetch_int(row, "calls")
+          input_t = fetch_int(row, "input_tokens")
+          output_t = fetch_int(row, "output_tokens")
+
+          lines << "  #{@formatter.pastel.bold(model)}"
+          lines << "    Calls: #{calls}  |  Input: #{format_number(input_t)}  |  Output: #{format_number(output_t)}  |  Cost: #{format_usd(cost)}"
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def header(title)
+        bar = @formatter.pastel.dim("-" * 40)
+        "#{bar}\n  #{@formatter.pastel.bold(title)}\n#{bar}"
+      end
+
+      def field(label, value)
+        "  #{@formatter.pastel.dim("#{label}:")} #{value}"
+      end
+
+      def format_usd(amount)
+        "$%.4f" % amount
+      end
+
+      def format_number(n)
+        n.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+      end
+
+      def fetch_int(row, key)
+        (row[key] || row[key.to_sym] || 0).to_i
+      end
+
+      def fetch_float(row, key)
+        (row[key] || row[key.to_sym] || 0.0).to_f
+      end
+    end
+  end
+end

data/lib/rubyn_code/output/diff_renderer.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module RubynCode
+  module Output
+    class DiffRenderer
+      # Immutable value object representing a single hunk in a unified diff.
+      Hunk = Data.define(:old_start, :old_count, :new_start, :new_count, :lines)
+
+      # Represents a single diff line with its type and content.
+      DiffLine = Data.define(:type, :content) do
+        def addition? = type == :add
+        def deletion? = type == :delete
+        def context?  = type == :context
+      end
+
+      attr_reader :pastel
+
+      # @param enabled [Boolean] whether color output is enabled
+      # @param context_lines [Integer] number of context lines around changes
+      def initialize(enabled: $stdout.tty?, context_lines: 3)
+        @pastel = Pastel.new(enabled: enabled)
+        @context_lines = context_lines
+      end
+
+      # Renders a unified diff between old_text and new_text.
+      #
+      # @param old_text [String] the original text
+      # @param new_text [String] the modified text
+      # @param filename [String] the filename to display in the diff header
+      # @return [String] the rendered, colorized diff output
+      def render(old_text, new_text, filename: "file")
+        old_lines = old_text.lines.map(&:chomp)
+        new_lines = new_text.lines.map(&:chomp)
+
+        hunks = compute_hunks(old_lines, new_lines)
+        return pastel.dim("No differences found.") if hunks.empty?
+
+        parts = []
+        parts << render_header(filename)
+        hunks.each { |hunk| parts << render_hunk(hunk) }
+        parts << ""
+
+        result = parts.join("\n")
+        $stdout.puts(result)
+        result
+      end
+
+      private
+
+      def render_header(filename)
+        [
+          pastel.bold("--- a/#{filename}"),
+          pastel.bold("+++ b/#{filename}")
+        ].join("\n")
+      end
+
+      def render_hunk(hunk)
+        header = pastel.cyan(
+          "@@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@"
+        )
+
+        rendered_lines = hunk.lines.map do |diff_line|
+          case diff_line
+          in DiffLine[type: :add, content:]
+            pastel.green("+#{content}")
+          in DiffLine[type: :delete, content:]
+            pastel.red("-#{content}")
+          in DiffLine[type: :context, content:]
+            pastel.dim(" #{content}")
+          end
+        end
+
+        [header, *rendered_lines].join("\n")
+      end
+
+      # Computes unified-diff hunks using the Myers diff algorithm (simple LCS approach).
+      def compute_hunks(old_lines, new_lines)
+        lcs_table = build_lcs_table(old_lines, new_lines)
+        raw_diff = backtrack_diff(lcs_table, old_lines, new_lines)
+        group_into_hunks(raw_diff, old_lines, new_lines)
+      end
+
+      # Builds the LCS length table for two arrays of lines.
+      def build_lcs_table(old_lines, new_lines)
+        m = old_lines.size
+        n = new_lines.size
+        table = Array.new(m + 1) { Array.new(n + 1, 0) }
+
+        (1..m).each do |i|
+          (1..n).each do |j|
+            table[i][j] = if old_lines[i - 1] == new_lines[j - 1]
+                            table[i - 1][j - 1] + 1
+                          else
+                            [table[i - 1][j], table[i][j - 1]].max
+                          end
+          end
+        end
+
+        table
+      end
+
+      # Backtracks through the LCS table to produce a sequence of diff operations.
+      # Returns an array of [:equal, :delete, :add] paired with line indices.
+      def backtrack_diff(table, old_lines, new_lines)
+        result = []
+        i = old_lines.size
+        j = new_lines.size
+
+        while i.positive? || j.positive?
+          if i.positive? && j.positive? && old_lines[i - 1] == new_lines[j - 1]
+            result.unshift([:equal, i - 1, j - 1])
+            i -= 1
+            j -= 1
+          elsif j.positive? && (i.zero? || table[i][j - 1] >= table[i - 1][j])
+            result.unshift([:add, nil, j - 1])
+            j -= 1
+          elsif i.positive?
+            result.unshift([:delete, i - 1, nil])
+            i -= 1
+          end
+        end
+
+        result
+      end
+
+      # Groups raw diff operations into hunks with surrounding context lines.
+      def group_into_hunks(raw_diff, old_lines, new_lines)
+        # Identify change indices (non-equal operations)
+        change_indices = raw_diff.each_index.select { |idx| raw_diff[idx][0] != :equal }
+        return [] if change_indices.empty?
+
+        # Group changes that are within context_lines of each other
+        groups = []
+        current_group = [change_indices.first]
+
+        change_indices.drop(1).each do |idx|
+          if idx - current_group.last <= @context_lines * 2 + 1
+            current_group << idx
+          else
+            groups << current_group
+            current_group = [idx]
+          end
+        end
+        groups << current_group
+
+        # Build hunks from groups
+        groups.map do |group|
+          range_start = [group.first - @context_lines, 0].max
+          range_end = [group.last + @context_lines, raw_diff.size - 1].min
+
+          lines = []
+          old_start = nil
+          new_start = nil
+          old_count = 0
+          new_count = 0
+
+          (range_start..range_end).each do |idx|
+            op, old_idx, new_idx = raw_diff[idx]
+
+            case op
+            when :equal
+              old_start ||= old_idx + 1
+              new_start ||= new_idx + 1
+              lines << DiffLine.new(type: :context, content: old_lines[old_idx])
+              old_count += 1
+              new_count += 1
+            when :delete
+              old_start ||= old_idx + 1
+              new_start ||= (new_idx || find_new_start(raw_diff, idx)) + 1
+              lines << DiffLine.new(type: :delete, content: old_lines[old_idx])
+              old_count += 1
+            when :add
+              old_start ||= (old_idx || find_old_start(raw_diff, idx)) + 1
+              new_start ||= new_idx + 1
+              lines << DiffLine.new(type: :add, content: new_lines[new_idx])
+              new_count += 1
+            end
+          end
+
+          old_start ||= 1
+          new_start ||= 1
+
+          Hunk.new(
+            old_start: old_start,
+            old_count: old_count,
+            new_start: new_start,
+            new_count: new_count,
+            lines: lines.freeze
+          )
+        end
+      end
+
+      # Find the nearest new-side line number for context when a delete has no new_idx.
+      def find_new_start(raw_diff, from_idx)
+        ((from_idx + 1)...raw_diff.size).each do |i|
+          return raw_diff[i][2] if raw_diff[i][2]
+        end
+        0
+      end
+
+      # Find the nearest old-side line number for context when an add has no old_idx.
+      def find_old_start(raw_diff, from_idx)
+        ((from_idx + 1)...raw_diff.size).each do |i|
+          return raw_diff[i][1] if raw_diff[i][1]
+        end
+        0
+      end
+    end
+  end
+end

data/lib/rubyn_code/output/formatter.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "rouge"
+
+module RubynCode
+  module Output
+    class Formatter
+      TOOL_ICON = "\u{1F527}"  # wrench
+      AGENT_ICON = "\u{1F916}" # robot
+
+      attr_reader :pastel
+
+      def initialize(enabled: $stdout.tty?)
+        @pastel = Pastel.new(enabled: enabled)
+      end
+
+      def success(message)
+        output pastel.green("\u2714 #{message}")
+      end
+
+      def error(message)
+        output pastel.red("\u2718 #{message}")
+      end
+
+      def warning(message)
+        output pastel.yellow("\u26A0 #{message}")
+      end
+
+      def info(message)
+        output pastel.cyan("\u2139 #{message}")
+      end
+
+      def dim(message)
+        output pastel.dim(message)
+      end
+
+      def bold(message)
+        output pastel.bold(message)
+      end
+
+      def code_block(code, language: "ruby")
+        lexer = find_lexer(language)
+        formatter = Rouge::Formatters::Terminal256.new(theme: Rouge::Themes::Monokai.new)
+
+        highlighted = formatter.format(lexer.lex(code))
+
+        lines = [
+          pastel.dim("\u2500" * 40),
+          highlighted,
+          pastel.dim("\u2500" * 40)
+        ]
+
+        output lines.join("\n")
+      end
+
+      def diff(text)
+        lines = text.each_line.map do |line|
+          case line
+          when /\A\+{3}\s/  then pastel.bold(line)
+          when /\A-{3}\s/   then pastel.bold(line)
+          when /\A@@/        then pastel.cyan(line)
+          when /\A\+/        then pastel.green(line)
+          when /\A-/         then pastel.red(line)
+          else                    pastel.dim(line)
+          end
+        end
+
+        output lines.join
+      end
+
+      def tool_call(tool_name, arguments = {})
+        header = pastel.magenta.bold("#{TOOL_ICON} #{tool_name}")
+        parts = [header]
+
+        unless arguments.empty?
+          args_display = arguments.map do |key, value|
+            display_value = truncate(value.to_s, 120)
+            "  #{pastel.dim("#{key}:")} #{display_value}"
+          end
+          parts.concat(args_display)
+        end
+
+        output parts.join("\n")
+      end
+
+      def tool_result(tool_name, result, success: true)
+        status = success ? pastel.green("\u2714") : pastel.red("\u2718")
+        header = pastel.magenta("#{status} #{tool_name}")
+        result_text = truncate(result.to_s, 500)
+
+        output "#{header}\n#{pastel.dim(result_text)}"
+      end
+
+      def agent_message(message)
+        prefix = pastel.blue.bold("#{AGENT_ICON} Assistant")
+        output "#{prefix}\n#{message}"
+      end
+
+      private
+
+      def output(text)
+        $stdout.puts(text)
+        text
+      end
+
+      def truncate(text, max_length)
+        return text if text.length <= max_length
+
+        "#{text[0, max_length]}#{pastel.dim("... (truncated)")}"
+      end
+
+      def find_lexer(language)
+        Rouge::Lexer.find(language.to_s) || Rouge::Lexers::PlainText.new
+      rescue StandardError
+        Rouge::Lexers::PlainText.new
+      end
+    end
+  end
+end

data/lib/rubyn_code/permissions/deny_list.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Permissions
+    class DenyList
+      attr_reader :names, :prefixes
+
+      # @param names [Array<String>] exact tool names to deny
+      # @param prefixes [Array<String>] tool name prefixes to deny
+      def initialize(names: [], prefixes: [])
+        @names    = Set.new(names.map(&:to_s))
+        @prefixes = Set.new(prefixes.map(&:to_s))
+      end
+
+      # Returns true if the given tool name is blocked by an exact name match
+      # or by a prefix match.
+      #
+      # @param tool_name [String]
+      # @return [Boolean]
+      def blocks?(tool_name)
+        name = tool_name.to_s
+        return true if @names.include?(name)
+
+        @prefixes.any? { |prefix| name.start_with?(prefix) }
+      end
+
+      # @param name [String] exact tool name to add to the deny list
+      # @return [self]
+      def add_name(name)
+        @names.add(name.to_s)
+        self
+      end
+
+      # @param prefix [String] tool name prefix to add to the deny list
+      # @return [self]
+      def add_prefix(prefix)
+        @prefixes.add(prefix.to_s)
+        self
+      end
+
+      # @param name [String] exact tool name to remove from the deny list
+      # @return [self]
+      def remove_name(name)
+        @names.delete(name.to_s)
+        self
+      end
+    end
+  end
+end

data/lib/rubyn_code/permissions/policy.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Permissions
+    module Policy
+      # Determine whether a tool invocation should be allowed, denied, or
+      # requires user confirmation.
+      #
+      # @param tool_name [String]
+      # @param tool_input [Hash]
+      # @param tier [Symbol] one of Tier::ALL
+      # @param deny_list [DenyList]
+      # @return [Symbol] :allow, :deny, or :ask
+      # Tool calls that are always auto-approved regardless of permission tier
+      ALWAYS_ALLOW = %w[
+        read_file glob grep git_status git_diff git_log
+        memory_search memory_write load_skill compact
+        task web_search web_fetch
+      ].to_set.freeze
+
+      def self.check(tool_name:, tool_input:, tier:, deny_list:)
+        return :deny if deny_list.blocks?(tool_name)
+        return :allow if ALWAYS_ALLOW.include?(tool_name)
+
+        risk = resolve_risk(tool_name)
+
+        return :ask if risk == :destructive
+
+        case tier
+        when Tier::ASK_ALWAYS
+          :ask
+        when Tier::ALLOW_READ
+          risk == :read ? :allow : :ask
+        when Tier::AUTONOMOUS
+          risk == :external ? :ask : :allow
+        when Tier::UNRESTRICTED
+          :allow
+        else
+          :ask
+        end
+      end
+
+      # Resolve the risk level for a tool by looking it up in the registry.
+      # Falls back to :unknown if the tool class cannot be found, which will
+      # be treated conservatively (requires confirmation in most tiers).
+      #
+      # @param tool_name [String]
+      # @return [Symbol] :read, :write, :external, :destructive, or :unknown
+      def self.resolve_risk(tool_name)
+        tool_class = Tools::Registry.get(tool_name)
+        tool_class.risk_level
+      rescue ToolNotFoundError
+        :unknown
+      end
+
+      private_class_method :resolve_risk
+    end
+  end
+end

data/lib/rubyn_code/permissions/prompter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "pastel"
+require "json"
+
+module RubynCode
+  module Permissions
+    module Prompter
+      # Ask the user to confirm a regular tool invocation.
+      #
+      # @param tool_name [String]
+      # @param tool_input [Hash]
+      # @return [Boolean] true if the user approved
+      def self.confirm(tool_name, tool_input)
+        prompt = build_prompt
+        pastel = Pastel.new
+
+        display_tool_summary(pastel, tool_name, tool_input)
+
+        prompt.yes?(
+          pastel.yellow("Allow this tool call?"),
+          default: true
+        )
+      rescue TTY::Prompt::Reader::InputInterrupt
+        false
+      end
+
+      # Ask the user to confirm a destructive tool invocation.
+      # Requires the user to type "yes" explicitly rather than just pressing Enter.
+      #
+      # @param tool_name [String]
+      # @param tool_input [Hash]
+      # @return [Boolean] true if the user approved
+      def self.confirm_destructive(tool_name, tool_input)
+        prompt = build_prompt
+        pastel = Pastel.new
+
+        $stdout.puts pastel.red.bold("WARNING: Destructive operation requested")
+        $stdout.puts pastel.red("=" * 50)
+        display_tool_summary(pastel, tool_name, tool_input)
+        $stdout.puts pastel.red("=" * 50)
+
+        answer = prompt.ask(
+          pastel.red.bold('Type "yes" to confirm this destructive action:')
+        )
+
+        answer&.strip&.downcase == "yes"
+      rescue TTY::Prompt::Reader::InputInterrupt
+        false
+      end
+
+      # @api private
+      def self.build_prompt
+        TTY::Prompt.new(interrupt: :noop)
+      end
+
+      # @api private
+      def self.display_tool_summary(pastel, tool_name, tool_input)
+        $stdout.puts pastel.magenta.bold("Tool: #{tool_name}")
+
+        return if tool_input.nil? || tool_input.empty?
+
+        tool_input.each do |key, value|
+          display_value = truncate_value(value.to_s, 200)
+          $stdout.puts "  #{pastel.dim("#{key}:")} #{display_value}"
+        end
+      end
+
+      # @api private
+      def self.truncate_value(text, max_length)
+        return text if text.length <= max_length
+
+        "#{text[0, max_length]}... (truncated)"
+      end
+
+      private_class_method :build_prompt, :display_tool_summary, :truncate_value
+    end
+  end
+end

data/lib/rubyn_code/permissions/tier.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Permissions
+    module Tier
+      ASK_ALWAYS   = :ask_always
+      ALLOW_READ   = :allow_read
+      AUTONOMOUS   = :autonomous
+      UNRESTRICTED = :unrestricted
+
+      ALL = [ASK_ALWAYS, ALLOW_READ, AUTONOMOUS, UNRESTRICTED].freeze
+
+      def self.all
+        ALL
+      end
+
+      def self.valid?(tier)
+        ALL.include?(tier)
+      end
+    end
+  end
+end