rubyn 0.1.0

data/lib/rubyn/engine/app/views/rubyn/specs/show.html.erb

@@ -0,0 +1,28 @@
+<% content_for(:title) { "Spec Generator" } %>
+
+<div class="rubyn-page-header">
+  <h1>Spec Generator</h1>
+  <p>AI-generated RSpec tests</p>
+</div>
+
+<% if @file %>
+  <div class="rubyn-tool-container">
+    <div class="rubyn-tool-header">
+      <span class="rubyn-tool-filepath">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"/><polyline points="14 2 14 8 20 8"/></svg>
+        <%= @file %>
+      </span>
+    </div>
+    <div class="rubyn-tool-body" id="spec-container">
+      <div class="rubyn-loading">
+        <span class="rubyn-spinner"></span>
+        Generating specs<span class="rubyn-dots"><span></span><span></span><span></span></span>
+      </div>
+    </div>
+  </div>
+<% else %>
+  <div class="rubyn-tool-empty">
+    <svg width="48" height="48" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" opacity="0.3"><path d="M9 5H7a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2M9 5a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2M9 5a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2"/></svg>
+    <p>Select a file from the <%= link_to "file browser", rubyn.files_path %>.</p>
+  </div>
+<% end %>

data/lib/rubyn/engine/config/routes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Rubyn::Engine.routes.draw do
+  root to: "dashboard#index"
+
+  resources :files, only: [:index]
+  resource :agent, only: %i[show create], controller: "agent"
+  resource :refactor, only: %i[show create update], controller: "refactor"
+  resource :specs, only: %i[show create], controller: "specs"
+  resource :reviews, only: %i[show create], controller: "reviews"
+  resource :settings, only: %i[show update], controller: "settings"
+  post "feedback", to: "feedback#create"
+end

data/lib/rubyn/engine/engine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rubyn
+  class Engine < ::Rails::Engine
+    isolate_namespace Rubyn
+
+    # Engine files live under lib/rubyn/engine/ instead of the gem root
+    engine_root = File.expand_path("..", __FILE__)
+
+    config.root = engine_root
+
+    initializer "rubyn.assets" do |app|
+      if Rails.env.development? && app.config.respond_to?(:assets)
+        app.config.assets.precompile += %w[rubyn/application.css rubyn/application.js rubyn/RubynLogo.png]
+      end
+    end
+  end
+end

data/lib/rubyn/output/diff_renderer.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubyn
+  module Output
+    class DiffRenderer
+      class << self
+        def render(original:, modified:)
+          original_lines = original.lines
+          modified_lines = modified.lines
+
+          pastel = Pastel.new
+          output = []
+          output << pastel.bold("--- original")
+          output << pastel.bold("+++ modified")
+
+          diff = compute_diff(original_lines, modified_lines)
+          diff.each do |change|
+            case change[:type]
+            when :unchanged
+              output << " #{change[:line]}"
+            when :removed
+              output << pastel.red("- #{change[:line]}")
+            when :added
+              output << pastel.green("+ #{change[:line]}")
+            end
+          end
+
+          puts output.join
+        end
+
+        private
+
+        def compute_diff(original, modified)
+          changes = []
+          orig_idx = 0
+          mod_idx = 0
+
+          lcs = compute_lcs(original, modified)
+          lcs_idx = 0
+
+          while orig_idx < original.size || mod_idx < modified.size
+            if lcs_idx < lcs.size && orig_idx < original.size && original[orig_idx] == lcs[lcs_idx] &&
+               mod_idx < modified.size && modified[mod_idx] == lcs[lcs_idx]
+              changes << { type: :unchanged, line: original[orig_idx] }
+              orig_idx += 1
+              mod_idx += 1
+              lcs_idx += 1
+            elsif orig_idx < original.size && (lcs_idx >= lcs.size || original[orig_idx] != lcs[lcs_idx])
+              changes << { type: :removed, line: original[orig_idx] }
+              orig_idx += 1
+            elsif mod_idx < modified.size
+              changes << { type: :added, line: modified[mod_idx] }
+              mod_idx += 1
+            end
+          end
+
+          changes
+        end
+
+        def compute_lcs(a, b)
+          dp = build_dp_table(a, b)
+          backtrack_lcs(dp, a, b)
+        end
+
+        def build_dp_table(a, b)
+          m = a.size
+          n = b.size
+          dp = Array.new(m + 1) { Array.new(n + 1, 0) }
+
+          (1..m).each do |i|
+            (1..n).each do |j|
+              dp[i][j] = if a[i - 1] == b[j - 1]
+                           dp[i - 1][j - 1] + 1
+                         else
+                           [dp[i - 1][j], dp[i][j - 1]].max
+                         end
+            end
+          end
+
+          dp
+        end
+
+        def backtrack_lcs(dp, a, b)
+          lcs = []
+          i = a.size
+          j = b.size
+          while i.positive? && j.positive?
+            if a[i - 1] == b[j - 1]
+              lcs.unshift(a[i - 1])
+              i -= 1
+              j -= 1
+            elsif dp[i - 1][j] > dp[i][j - 1]
+              i -= 1
+            else
+              j -= 1
+            end
+          end
+
+          lcs
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/output/formatter.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "rouge"
+
+module Rubyn
+  module Output
+    class Formatter
+      class << self
+        def header(text)
+          puts "\n#{pastel.bold(text)}"
+          puts pastel.dim("\u2500" * text.length)
+        end
+
+        def success(text)
+          puts pastel.green("\u2713 #{text}")
+        end
+
+        def warning(text)
+          puts pastel.yellow("\u26A0 #{text}")
+        end
+
+        def error(text)
+          puts pastel.red("\u2717 #{text}")
+        end
+
+        def info(text)
+          puts pastel.cyan("\u2192 #{text}")
+        end
+
+        def code_block(code, language: "ruby")
+          puts highlight(code, language)
+        end
+
+        def credit_usage(credits, balance = nil)
+          if balance
+            puts pastel.dim("Credits: #{credits} used | #{balance} remaining")
+          else
+            puts pastel.dim("Credits: #{credits} used")
+          end
+        end
+
+        def stream_print(text)
+          print text
+        end
+
+        # Print response with syntax-highlighted code blocks
+        def print_content(text)
+          print_with_highlighted_code(text)
+        end
+
+        def newline
+          puts
+        end
+
+        private
+
+        def pastel
+          @pastel ||= Pastel.new
+        end
+
+        def rouge_formatter
+          @rouge_formatter ||= Rouge::Formatters::Terminal256.new(
+            theme: Rouge::Themes::Monokai.new
+          )
+        end
+
+        def highlight(code, language = "ruby")
+          lexer = Rouge::Lexer.find(language) || Rouge::Lexers::Ruby.new
+          rouge_formatter.format(lexer.lex(code))
+        rescue Rouge::Error, ArgumentError
+          code
+        end
+
+        # Parse markdown-style code blocks and highlight them,
+        # pass everything else through as plain text
+        def print_with_highlighted_code(text)
+          in_code_block = false
+          language = "ruby"
+          code_buffer = []
+
+          text.each_line do |line|
+            if line.match?(/^```(\w*)/)
+              if in_code_block
+                # End of code block — highlight and print
+                puts highlight(code_buffer.join, language)
+                puts pastel.dim("```")
+                code_buffer = []
+                in_code_block = false
+              else
+                # Start of code block
+                language = line.match(/^```(\w+)/)&.send(:[], 1) || "ruby"
+                puts pastel.dim(line.chomp)
+                in_code_block = true
+              end
+            elsif in_code_block
+              code_buffer << line
+            else
+              # Regular text — print with light formatting
+              print_formatted_line(line)
+            end
+          end
+
+          # Flush any unclosed code block
+          puts code_buffer.join if code_buffer.any?
+        end
+
+        def print_formatted_line(line)
+          case line
+          when /^\#{1,3}\s/
+            puts pastel.bold(line.chomp)
+          when /^\*\*(.+)\*\*/
+            puts pastel.bold(line.gsub(/\*\*(.+?)\*\*/, '\1').chomp)
+          when /^[-*]\s/
+            puts pastel.cyan("  #{line.chomp}")
+          else
+            puts line.chomp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/output/spinner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+
+module Rubyn
+  module Output
+    class Spinner
+      def initialize
+        @spinner = nil
+      end
+
+      def start(message)
+        @spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots)
+        @spinner.auto_spin
+      end
+
+      def stop_success(message = "Done!")
+        @spinner&.success(message)
+      end
+
+      def stop_error(message = "Failed!")
+        @spinner&.error(message)
+      end
+    end
+  end
+end

data/lib/rubyn/tools/base_tool.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class BaseTool
+      attr_reader :project_root
+
+      DESCRIPTION = "Base tool"
+      PARAMETERS = {}.freeze
+      REQUIRES_CONFIRMATION = false
+
+      def initialize(project_root = Dir.pwd)
+        @project_root = project_root
+      end
+
+      def call(raw_params)
+        params = self.class.symbolize_params(raw_params)
+        execute(params)
+      end
+
+      def execute(params)
+        raise NotImplementedError, "#{self.class}#execute must be implemented"
+      end
+
+      def requires_confirmation?
+        self.class::REQUIRES_CONFIRMATION
+      end
+
+      # Normalize string keys to symbol keys so tools can use params[:key]
+      def self.symbolize_params(params)
+        return {} unless params.is_a?(Hash)
+
+        params.each_with_object({}) do |(k, v), h|
+          h[k.to_sym] = v
+        end
+      end
+
+      EXCLUDED_DIRS = %w[.git node_modules vendor/bundle vendor tmp].freeze
+      DEFAULT_MAX_OUTPUT_LENGTH = 10_000
+
+      private
+
+      def excluded?(path)
+        rel = relative_path(path)
+        EXCLUDED_DIRS.any? { |dir| rel.start_with?("#{dir}/") || rel.include?("/#{dir}/") }
+      end
+
+      def truncate_output(output, max_length = self.class::DEFAULT_MAX_OUTPUT_LENGTH)
+        return output if output.length <= max_length
+
+        output[0...max_length] + "\n... (truncated, #{output.length} total chars)"
+      end
+
+      def resolve_path(path)
+        expanded = File.expand_path(path, project_root)
+        return error("Access denied: path is outside project root") unless expanded.start_with?(project_root)
+
+        expanded
+      end
+
+      def relative_path(full_path)
+        full_path.sub("#{project_root}/", "")
+      end
+
+      def success(data)
+        { success: true }.merge(data)
+      end
+
+      def error(message)
+        { success: false, error: message }
+      end
+    end
+  end
+end

data/lib/rubyn/tools/bundle_add.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class BundleAdd < BaseTool
+      DESCRIPTION = "Add a gem to the Gemfile and run bundle install"
+      PARAMETERS = {
+        gem_name: { type: :string, description: "Name of the gem to add", required: true },
+        version: { type: :string, description: "Version constraint (e.g. ~> 2.0)", required: false },
+        group: { type: :string, description: "Gemfile group (e.g. development, test)", required: false }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        gem_name = params[:gem_name]
+        return error("gem_name is required") unless gem_name && !gem_name.strip.empty?
+
+        gemfile_path = File.join(project_root, "Gemfile")
+        return error("Gemfile not found in project root") unless File.exist?(gemfile_path)
+
+        gem_line = build_gem_line(gem_name, params[:version])
+        group = params[:group]
+
+        begin
+          gemfile_content = File.read(gemfile_path)
+
+          gemfile_content = if group && !group.strip.empty?
+                              insert_into_group(gemfile_content, group, gem_line)
+                            else
+                              "#{gemfile_content.rstrip}\n#{gem_line}\n"
+                            end
+
+          File.write(gemfile_path, gemfile_content)
+        rescue StandardError => e
+          return error("Failed to update Gemfile: #{e.message}")
+        end
+
+        begin
+          stdout, stderr, status = Open3.capture3("bundle install", chdir: project_root)
+        rescue StandardError => e
+          return error("Failed to run bundle install: #{e.message}")
+        end
+
+        return error("bundle install failed: #{stderr}") unless status.exitstatus.zero?
+
+        success(gem_name: gem_name, output: stdout)
+      end
+
+      private
+
+      def build_gem_line(gem_name, version)
+        if version && !version.strip.empty?
+          "gem \"#{gem_name}\", \"#{version}\""
+        else
+          "gem \"#{gem_name}\""
+        end
+      end
+
+      def insert_into_group(content, group, gem_line)
+        group_pattern = /^group\s+:#{Regexp.escape(group)}.*?\bdo\b/
+        if content.match?(group_pattern)
+          content.sub(group_pattern) do |match|
+            "#{match}\n  #{gem_line}"
+          end
+        else
+          "#{content.rstrip}\n\ngroup :#{group} do\n  #{gem_line}\nend\n"
+        end
+      end
+    end
+
+    Registry.register("bundle_add", BundleAdd)
+  end
+end

data/lib/rubyn/tools/create_file.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class CreateFile < BaseTool
+      DESCRIPTION = "Create a new file. Fails if the file already exists."
+      PARAMETERS = {
+        path: { type: :string, description: "Path to the file to create", required: true },
+        content: { type: :string, description: "Content to write to the new file", required: true }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        resolved = resolve_path(params[:path])
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        return error("File already exists: #{params[:path]}") if File.exist?(resolved)
+
+        FileUtils.mkdir_p(File.dirname(resolved))
+        bytes_written = File.write(resolved, params[:content])
+
+        success(path: params[:path], bytes_written: bytes_written)
+      end
+    end
+
+    Registry.register("create_file", CreateFile)
+  end
+end

data/lib/rubyn/tools/delete_file.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+require_relative "registry"
+
+module Rubyn
+  module Tools
+    class DeleteFile < BaseTool
+      DESCRIPTION = "Delete a file"
+      PARAMETERS = {
+        path: { type: :string, description: "Path to the file to delete", required: true }
+      }.freeze
+      REQUIRES_CONFIRMATION = true
+
+      def execute(params)
+        resolved = resolve_path(params[:path])
+        return resolved if resolved.is_a?(Hash) && resolved[:error]
+
+        return error("File not found: #{params[:path]}") unless File.exist?(resolved)
+
+        File.delete(resolved)
+
+        success(path: params[:path])
+      end
+    end
+
+    Registry.register("delete_file", DeleteFile)
+  end
+end

data/lib/rubyn/tools/executor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class Executor
+      attr_reader :project_root, :auto_confirm
+
+      def initialize(project_root = Dir.pwd, auto_confirm: false)
+        @project_root = project_root
+        @auto_confirm = auto_confirm
+      end
+
+      # server_requires_confirmation: the API's flag for whether this call needs user approval.
+      # Falls back to the tool's local REQUIRES_CONFIRMATION constant if not provided.
+      def execute(tool_name, params, server_requires_confirmation: nil)
+        klass = Registry.get(tool_name)
+        return { success: false, error: "Unknown tool: #{tool_name}" } unless klass
+
+        tool = klass.new(project_root)
+
+        needs_confirmation = if server_requires_confirmation.nil?
+                               tool.requires_confirmation?
+                             else
+                               server_requires_confirmation
+                             end
+
+        if needs_confirmation && !auto_confirm && !confirm_action(tool_name, params)
+          return { success: false, error: "denied_by_user" }
+        end
+
+        tool.call(params)
+      rescue StandardError => e
+        { success: false, error: "#{e.class}: #{e.message}" }
+      end
+
+      private
+
+      def confirm_action(tool_name, params)
+        summary = format_action(tool_name, params)
+        Rubyn::Output::Formatter.warning("Agent wants to: #{summary}")
+        print "Allow? (y/n) "
+        response = $stdin.gets&.strip&.downcase
+        response == "y"
+      end
+
+      ACTION_FORMATTERS = {
+        "write_file"        => ->(p) { "write to #{p[:path]}" },
+        "create_file"       => ->(p) { "write to #{p[:path]}" },
+        "patch_file"        => ->(p) { "edit #{p[:path]}" },
+        "delete_file"       => ->(p) { "delete #{p[:path]}" },
+        "move_file"         => ->(p) { "move #{p[:source]} to #{p[:destination]}" },
+        "run_command"       => ->(p) { "run: #{p[:command]}" },
+        "run_tests"         => ->(p) { "run tests: #{p[:path] || "full suite"}" },
+        "rails_generate"    => ->(p) { "rails generate #{p[:generator]} #{p[:args]}" },
+        "rails_migrate"     => ->(_) { "rails db:migrate" },
+        "bundle_add"        => ->(p) { "add gem '#{p[:gem_name]}' to Gemfile" },
+        "git_commit"        => ->(p) { "git commit: #{p[:message]}" },
+        "git_create_branch" => ->(p) { "create branch: #{p[:branch_name]}" }
+      }.freeze
+
+      def format_action(tool_name, params)
+        p = BaseTool.symbolize_params(params)
+        formatter = ACTION_FORMATTERS[tool_name]
+        formatter ? formatter.call(p) : "#{tool_name} #{params.inspect}"
+      end
+    end
+  end
+end

data/lib/rubyn/tools/find_files.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Tools
+    class FindFiles < BaseTool
+      DESCRIPTION = "Find files matching a glob pattern"
+      PARAMETERS = {
+        pattern: { type: "string", required: true, description: "Glob pattern (e.g. 'app/models/**/*.rb')" }
+      }.freeze
+      REQUIRES_CONFIRMATION = false
+
+      MAX_RESULTS = 200
+
+      def execute(params)
+        pattern = params[:pattern]
+        return error("Missing required parameter: pattern") unless pattern
+
+        glob_path = File.join(project_root, pattern)
+        all_files = Dir.glob(glob_path, File::FNM_DOTMATCH)
+
+        files = all_files
+                .reject { |f| excluded?(f) }
+                .select { |f| File.file?(f) }
+                .first(MAX_RESULTS)
+                .map { |f| relative_path(f) }
+
+        success(pattern: pattern, files: files, count: files.size)
+      end
+    end
+  end
+end
+
+Rubyn::Tools::Registry.register("find_files", Rubyn::Tools::FindFiles)