rubyn 0.1.0

data/lib/rubyn/commands/refactor.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rubyn
+  module Commands
+    class Refactor < Base
+      def execute(file)
+        formatter = Rubyn::Output::Formatter
+        ensure_configured!
+        auto_index_if_needed!
+
+        unless File.exist?(file)
+          formatter.error("File not found: #{file}")
+          return
+        end
+
+        file_content = File.read(file)
+        relative_path = relative_to_project(file)
+        formatted_context = build_context_files(relative_path)
+
+        formatter.info("Analyzing #{File.basename(file)}...")
+        formatter.info("Context: #{formatted_context.size} related file(s)")
+        formatter.newline
+        begin
+          result = Rubyn.api_client.refactor(
+            file_path: relative_path,
+            code: file_content,
+            context_files: formatted_context,
+            project_token: project_token
+          )
+
+          full_response = result["response"] || ""
+          formatter.print_content(full_response)
+          formatter.newline
+          formatter.credit_usage(result["credits_used"], nil) if result["credits_used"]
+          formatter.newline
+          prompt_apply(file, file_content, full_response, formatter)
+        rescue Rubyn::AuthenticationError => e
+          formatter.error("Authentication failed: #{e.message}")
+        rescue Rubyn::APIError => e
+          formatter.error(e.message)
+        end
+      end
+
+      private
+
+      def prompt_apply(file, original, response, formatter)
+        file_blocks = extract_file_blocks(response)
+        return if file_blocks.empty?
+
+        if file_blocks.length == 1 && file_blocks.first[:tag].nil?
+          prompt_apply_single(file, original, file_blocks.first[:code], formatter)
+        else
+          prompt_apply_multi(file, original, file_blocks, formatter)
+        end
+      end
+
+      def extract_file_blocks(response)
+        blocks = []
+
+        # Match path header lines directly above ```ruby blocks
+        # Handles: `[NEW] path.rb`, `path.rb`, backtick-wrapped or plain
+        response.scan(/(?:\[NEW\]\s*)?`?([a-zA-Z0-9_\/\.\-]+\.rb)`?\s*\n```ruby\n(.*?)```/m) do
+          path = $1
+          code = $2
+          is_new = $~[0].include?("[NEW]")
+          blocks << { tag: is_new ? "NEW" : nil, path: path, code: code }
+        end
+
+        # Fallback: no path headers found, grab first code block
+        if blocks.empty?
+          code_match = response.match(/```ruby\n(.*?)```/m)
+          blocks << { tag: nil, path: nil, code: code_match[1] } if code_match
+        end
+
+        blocks
+      end
+
+      def prompt_apply_single(file, original, new_content, formatter)
+        print "\nApply changes? (y/n/diff) "
+        choice = $stdin.gets&.strip&.downcase
+
+        case choice
+        when "y"
+          File.write(file, new_content)
+          formatter.success("Changes applied to #{file}")
+        when "diff"
+          Rubyn::Output::DiffRenderer.render(original: original, modified: new_content)
+          print "\nApply changes? (y/n) "
+          if $stdin.gets&.strip&.downcase == "y"
+            File.write(file, new_content)
+            formatter.success("Changes applied to #{file}")
+          else
+            formatter.info("Changes discarded.")
+          end
+        else
+          formatter.info("Changes discarded.")
+        end
+      end
+
+      def prompt_apply_multi(file, original, file_blocks, formatter)
+        formatter.newline
+        formatter.info("This refactor produces #{file_blocks.length} file(s):")
+        file_blocks.each do |block|
+          label = block[:tag] == "NEW" ? "NEW" : "MODIFIED"
+          path = block[:path] || file
+          formatter.info("  [#{label}] #{path}")
+        end
+
+        print "\nApply all changes? (y/n/select) "
+        choice = $stdin.gets&.strip&.downcase
+
+        case choice
+        when "y"
+          apply_all_blocks(file, original, file_blocks, formatter)
+        when "select"
+          apply_selected_blocks(file, original, file_blocks, formatter)
+        else
+          formatter.info("All changes discarded.")
+        end
+      end
+
+      def apply_all_blocks(file, original, file_blocks, formatter)
+        file_blocks.each do |block|
+          write_block(file, block, formatter)
+        end
+      end
+
+      def apply_selected_blocks(file, original, file_blocks, formatter)
+        file_blocks.each do |block|
+          label = block[:tag] == "NEW" ? "NEW" : "MODIFIED"
+          path = block[:path] || file
+          print "  Apply [#{label}] #{path}? (y/n/diff) "
+          choice = $stdin.gets&.strip&.downcase
+
+          case choice
+          when "y"
+            write_block(file, block, formatter)
+          when "diff"
+            existing = block[:tag] == "NEW" ? "" : File.read(resolve_path(file, block))
+            Rubyn::Output::DiffRenderer.render(original: existing, modified: block[:code])
+            print "  Apply? (y/n) "
+            if $stdin.gets&.strip&.downcase == "y"
+              write_block(file, block, formatter)
+            else
+              formatter.info("  Skipped #{path}")
+            end
+          else
+            formatter.info("  Skipped #{path}")
+          end
+        end
+      end
+
+      def write_block(original_file, block, formatter)
+        target = resolve_path(original_file, block)
+        dir = File.dirname(target)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+        File.write(target, block[:code])
+        label = block[:tag] == "NEW" ? "Created" : "Updated"
+        formatter.success("#{label} #{target}")
+      end
+
+      def resolve_path(original_file, block)
+        return original_file unless block[:path]
+
+        if block[:path].start_with?("/")
+          block[:path]
+        else
+          File.join(Dir.pwd, block[:path])
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/commands/review.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Commands
+    class Review < Base
+      def execute(file_or_dir)
+        formatter = Rubyn::Output::Formatter
+        ensure_configured!
+        auto_index_if_needed!
+
+        files = resolve_files(file_or_dir)
+        if files.empty?
+          formatter.error("No Ruby files found in: #{file_or_dir}")
+          return
+        end
+
+        formatter.info("Reviewing #{files.size} file(s)...")
+        formatter.newline
+
+        formatted_files = files.map do |file|
+          { file_path: relative_to_project(file), code: File.read(file) }
+        end
+
+        file_paths = files.map { |f| relative_to_project(f) }
+        formatted_context = file_paths.flat_map { |rel_path| build_context_files(rel_path) }
+                                      .uniq { |ctx| ctx[:file_path] }
+                                      .reject { |ctx| file_paths.include?(ctx[:file_path]) }
+
+        formatter.header(formatted_files.map { |f| f[:file_path] }.join(", "))
+
+        begin
+          result = Rubyn.api_client.review(
+            files: formatted_files,
+            context_files: formatted_context,
+            project_token: project_token
+          )
+
+          formatter.print_content(result["response"] || "")
+          formatter.newline
+          formatter.credit_usage(result["credits_used"], nil) if result["credits_used"]
+        rescue Rubyn::AuthenticationError => e
+          formatter.error("Authentication failed: #{e.message}")
+        rescue Rubyn::APIError => e
+          formatter.error(e.message)
+        end
+      end
+
+      private
+
+      def resolve_files(path)
+        if File.directory?(path)
+          Dir.glob(File.join(path, "**/*.rb"))
+        elsif File.exist?(path)
+          [path]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/commands/spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Commands
+    class Spec < Base
+      def execute(file)
+        formatter = Rubyn::Output::Formatter
+        ensure_configured!
+        auto_index_if_needed!
+
+        unless File.exist?(file)
+          formatter.error("File not found: #{file}")
+          return
+        end
+
+        file_content = File.read(file)
+        relative_path = relative_to_project(file)
+        formatted_context = build_context_files(relative_path)
+
+        formatter.info("Generating specs for #{File.basename(file)}...")
+        formatter.newline
+        begin
+          result = Rubyn.api_client.generate_spec(
+            file_path: relative_path,
+            code: file_content,
+            context_files: formatted_context,
+            project_token: project_token
+          )
+
+          full_response = result["response"] || ""
+          formatter.print_content(full_response)
+          formatter.newline
+          formatter.credit_usage(result["credits_used"], nil) if result["credits_used"]
+          formatter.newline
+          prompt_write_spec(relative_path, full_response, formatter)
+        rescue Rubyn::AuthenticationError => e
+          formatter.error("Authentication failed: #{e.message}")
+        rescue Rubyn::APIError => e
+          formatter.error(e.message)
+        end
+      end
+
+      private
+
+      def prompt_write_spec(source_path, response, formatter)
+        code_match = response.match(/```ruby\n(.*?)```/m)
+        return unless code_match
+
+        spec_content = code_match[1]
+        spec_path = derive_spec_path(source_path)
+
+        print "\nWrite spec to #{spec_path}? (y/n) "
+        choice = $stdin.gets&.strip&.downcase
+
+        if choice == "y"
+          FileUtils.mkdir_p(File.dirname(spec_path))
+          File.write(spec_path, spec_content)
+          formatter.success("Spec written to #{spec_path}")
+        else
+          formatter.info("Spec discarded.")
+        end
+      end
+
+      def derive_spec_path(source_path)
+        source_path
+          .sub(%r{^app/}, "spec/")
+          .sub(%r{^lib/}, "spec/")
+          .sub(/\.rb$/, "_spec.rb")
+      end
+    end
+  end
+end

data/lib/rubyn/commands/usage.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Commands
+    class Usage < Base
+      MAX_HISTORY_ENTRIES = 10
+
+      def execute
+        formatter = Rubyn::Output::Formatter
+        ensure_credentials!
+
+        formatter.header("Rubyn Usage")
+
+        spinner = Rubyn::Output::Spinner.new
+        spinner.start("Fetching usage data...")
+
+        balance = Rubyn.api_client.get_balance
+        history = Rubyn.api_client.get_history
+
+        spinner.stop_success("Done!")
+
+        display_balance(formatter, balance)
+        display_history(formatter, history)
+      rescue Rubyn::ConfigurationError
+        raise
+      rescue Rubyn::Error => e
+        spinner&.stop_error("Failed")
+        formatter.error(e.message)
+      end
+
+      private
+
+      def display_balance(formatter, balance)
+        formatter.newline
+        formatter.info("Credits: #{balance["credit_balance"]}")
+        formatter.info("Credit allowance: #{balance["credit_allowance"]}") if balance["credit_allowance"]
+        formatter.info("Reset period: #{balance["reset_period"]}") if balance["reset_period"]
+        formatter.info("Resets at: #{balance["resets_at"]}") if balance["resets_at"]
+        formatter.newline
+      end
+
+      def display_history(formatter, history)
+        entries = history["interactions"] || []
+        return formatter.info("No recent activity.") if entries.empty?
+
+        formatter.header("Recent Activity")
+        entries.first(MAX_HISTORY_ENTRIES).each do |entry|
+          time = entry["created_at"]
+          command = entry["command"]
+          credits = entry["credits_charged"]
+          formatter.info("#{time}  #{command.ljust(10)}  #{credits} credits")
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/config/credentials.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Rubyn
+  module Config
+    class Credentials
+      CREDENTIALS_DIR = File.expand_path("~/.rubyn")
+      CREDENTIALS_FILE = File.join(CREDENTIALS_DIR, "credentials")
+
+      class << self
+        def api_key
+          ENV["RUBYN_API_KEY"] || read_credentials["api_key"]
+        end
+
+        def store(api_key:)
+          FileUtils.mkdir_p(CREDENTIALS_DIR)
+          data = read_credentials.merge("api_key" => api_key)
+          File.write(CREDENTIALS_FILE, YAML.dump(data))
+          File.chmod(0o600, CREDENTIALS_FILE)
+          data
+        end
+
+        def exists?
+          !api_key.nil? && !api_key.empty?
+        end
+
+        private
+
+        def read_credentials
+          return {} unless File.exist?(CREDENTIALS_FILE)
+
+          YAML.safe_load_file(CREDENTIALS_FILE) || {}
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/config/project_config.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Rubyn
+  module Config
+    class ProjectConfig
+      CONFIG_DIR = ".rubyn"
+      CONFIG_FILE = File.join(CONFIG_DIR, "project.yml")
+
+      class << self
+        def read(project_root = Dir.pwd)
+          path = File.join(project_root, CONFIG_FILE)
+          return {} unless File.exist?(path)
+
+          YAML.safe_load_file(path) || {}
+        end
+
+        def write(data, project_root = Dir.pwd)
+          dir = File.join(project_root, CONFIG_DIR)
+          path = File.join(project_root, CONFIG_FILE)
+          FileUtils.mkdir_p(dir)
+          File.write(path, YAML.dump(data))
+          data
+        end
+
+        def exists?(project_root = Dir.pwd)
+          File.exist?(File.join(project_root, CONFIG_FILE))
+        end
+
+        def project_token(project_root = Dir.pwd)
+          read(project_root)["project_token"]
+        end
+
+        def project_id(project_root = Dir.pwd)
+          read(project_root)["project_id"]
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/config/settings.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Rubyn
+  module Config
+    class Settings
+      SETTINGS_DIR = File.expand_path("~/.rubyn")
+      SETTINGS_FILE = File.join(SETTINGS_DIR, "config.yml")
+
+      DEFAULTS = {
+        "default_model" => "haiku",
+        "auto_apply" => false,
+        "output_format" => "diff"
+      }.freeze
+
+      class << self
+        def get(key)
+          all[key.to_s]
+        end
+
+        def set(key, value)
+          data = all.merge(key.to_s => coerce_value(value))
+          FileUtils.mkdir_p(SETTINGS_DIR)
+          File.write(SETTINGS_FILE, YAML.dump(data))
+          data
+        end
+
+        def all
+          DEFAULTS.merge(read_settings)
+        end
+
+        private
+
+        def read_settings
+          return {} unless File.exist?(SETTINGS_FILE)
+
+          YAML.safe_load_file(SETTINGS_FILE) || {}
+        end
+
+        def coerce_value(value)
+          case value
+          when "true" then true
+          when "false" then false
+          when /\A\d+\z/ then value.to_i
+          else value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn/context/codebase_indexer.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "digest"
+require "yaml"
+require "fileutils"
+
+module Rubyn
+  module Context
+    class CodebaseIndexer
+      CACHE_FILE = ".rubyn/index_cache.yml"
+      BATCH_SIZE = 50
+
+      attr_reader :project_root
+
+      def initialize(project_root = Dir.pwd)
+        @project_root = project_root
+      end
+
+      # Yields progress events: { phase:, current:, total:, file:, message: }
+      def index(force: false, &on_progress)
+        ruby_files = find_ruby_files
+        cache = force ? {} : load_cache
+        changed_files = detect_changes(ruby_files, cache)
+
+        if changed_files.empty?
+          report(on_progress, phase: :complete, message: "Everything up to date")
+          return { indexed: 0, skipped: ruby_files.size, chunks: 0 }
+        end
+
+        report(on_progress, phase: :scan, message: "Found #{changed_files.size} files to analyse")
+
+        result = process_changed_files(changed_files, cache, on_progress)
+
+        report(on_progress, phase: :upload,
+                            message: "Uploading #{result[:files].size} files in #{batch_count(result[:files])} batches")
+
+        send_files(result[:files], on_progress)
+        save_cache(result[:cache])
+
+        report(on_progress, phase: :complete,
+                            message: "Analysed #{changed_files.size} files")
+
+        { indexed: changed_files.size, skipped: ruby_files.size - changed_files.size }
+      end
+
+      private
+
+      def process_changed_files(changed_files, cache, on_progress = nil)
+        all_files = []
+        new_cache = cache.dup
+
+        changed_files.each_with_index do |file, idx|
+          report(on_progress, phase: :chunk, current: idx + 1, total: changed_files.size, file: file)
+
+          content = File.read(File.join(project_root, file))
+          file_hash = Digest::SHA256.hexdigest(content)
+          all_files << { file_path: file, content: content, file_hash: file_hash }
+          new_cache[file] = file_hash
+        end
+
+        { files: all_files, cache: new_cache }
+      end
+
+      def chunk_file(file_path, content)
+        lines = content.lines
+        chunks = parse_chunks(file_path, lines)
+
+        if chunks.empty?
+          chunks << default_chunk(file_path, content, lines)
+        end
+
+        chunks
+      end
+
+      def parse_chunks(file_path, lines)
+        chunks = []
+        current_chunk = nil
+        current_start = nil
+        nesting = 0
+
+        lines.each_with_index do |line, index|
+          line_num = index + 1
+
+          if line.match?(/^\s*(class|module)\s+/)
+            finalize_chunk(chunks, current_chunk, file_path, current_start, line_num - 1) if current_chunk
+            current_chunk, current_start, nesting = start_class_or_module_chunk(line, line_num)
+          elsif line.match?(/^\s*def\s+/) && nesting <= 1
+            current_chunk, current_start = start_method_chunk(line, line_num, chunks, current_chunk, current_start, file_path)
+          else
+            current_chunk[:lines] << line if current_chunk
+
+            if line.match?(/\b(do|begin)\b/) || (line.match?(/\bclass\b|\bmodule\b|\bdef\b/) && !line.match?(/end/))
+              nesting += 1
+            end
+            nesting -= 1 if line.strip == "end"
+          end
+        end
+
+        finalize_chunk(chunks, current_chunk, file_path, current_start, lines.size) if current_chunk
+        chunks
+      end
+
+      def start_class_or_module_chunk(line, line_num)
+        match = line.match(/^\s*(class|module)\s+(\S+)/)
+        chunk = { type: match[1], name: match[2], lines: [line] }
+        [chunk, line_num, 1]
+      end
+
+      def start_method_chunk(line, line_num, chunks, current_chunk, current_start, file_path)
+        if current_chunk && current_chunk[:type] == "method"
+          finalize_chunk(chunks, current_chunk, file_path, current_start, line_num - 1)
+        end
+
+        match = line.match(/^\s*def\s+(\S+)/)
+        method_chunk = { type: "method", name: match[1], lines: [line] }
+
+        if current_chunk.nil?
+          [method_chunk, line_num]
+        else
+          current_chunk[:lines] << line
+          [current_chunk, current_start]
+        end
+      end
+
+      def default_chunk(file_path, content, lines)
+        {
+          file_path: file_path,
+          chunk_type: "file",
+          chunk_name: File.basename(file_path, ".rb"),
+          chunk_content: content,
+          line_start: 1,
+          line_end: lines.size
+        }
+      end
+
+      def report(callback, **data)
+        callback&.call(data)
+      end
+
+      def batch_count(chunks)
+        (chunks.size.to_f / BATCH_SIZE).ceil
+      end
+
+      def finalize_chunk(chunks, chunk, file_path, start_line, end_line)
+        return unless chunk
+
+        chunks << {
+          file_path: file_path,
+          chunk_type: chunk[:type],
+          chunk_name: chunk[:name],
+          chunk_content: chunk[:lines].join,
+          line_start: start_line,
+          line_end: end_line
+        }
+      end
+
+      def find_ruby_files
+        Dir.glob(File.join(project_root, "**/*.rb"))
+           .reject { |f| f.include?("/vendor/") || f.include?("/node_modules/") || f.include?("/.rubyn/") }
+           .map { |f| f.sub("#{project_root}/", "") }
+      end
+
+      def detect_changes(files, cache)
+        files.reject do |file|
+          full_path = File.join(project_root, file)
+          current_hash = Digest::SHA256.hexdigest(File.read(full_path))
+          cache[file] == current_hash
+        end
+      end
+
+      def load_cache
+        path = File.join(project_root, CACHE_FILE)
+        return {} unless File.exist?(path)
+
+        YAML.safe_load_file(path) || {}
+      end
+
+      def save_cache(cache)
+        path = File.join(project_root, CACHE_FILE)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, YAML.dump(cache))
+      end
+
+      def send_files(files, on_progress = nil)
+        project_token = Rubyn::Config::ProjectConfig.project_token
+        batches = files.each_slice(BATCH_SIZE).to_a
+
+        batches.each_with_index do |batch, idx|
+          report(on_progress, phase: :upload_batch, current: idx + 1, total: batches.size)
+          Rubyn.api_client.index_project(project_token: project_token, files: batch)
+        end
+      end
+    end
+  end
+end