rubyn 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b1ca55e10bd9ae4ec17fbdbfa196577fda468788c083905679a2c1e7e782181
-  data.tar.gz: f82e928da5975b754dca641f00488bb6360ffbd4cd45d538909348a4b1ff6b05
+  metadata.gz: db58e485a2422294e1c127b5a6347ac42304534013835d28c2fc67d59aea06df
+  data.tar.gz: 8e5ff68de409481dd622746ccb4331465db048df15743a357f18ac80a5a239c3
 SHA512:
-  metadata.gz: da671165752719684baaf371f4c1a47d7a9f3e8604af37360b106827d15c08a1508219b7fc47ae859a1c8f54f9e756a7e7a459c66fff4cbb718e70610eb4684a
-  data.tar.gz: 7f6f19c30b1ba42e74aeb0f3b0ec936d8f14ac63b6d52949d87c0714fce3b76c041c3cc8bf67a8eb07c36453b6d7602ae35736c46b1771646ce71bcebac748b4
+  metadata.gz: bb4224d7a928da8a211c3dc9e10e1c3753f8f524b55a79dbb3bfb89905a887ff5c1762a5a49c625d4a8b892826557d39aa498a8ba3f483ccb43da29212b734b6
+  data.tar.gz: a7807763294cc0defae24600c534736426d25653bd868c67c0c21b6fd161c4dbc32a3e4c33926a88b779b54f06b16db8e5874efd384ad46f79c72d56752a05cb

data/lib/rubyn/commands/refactor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-
 module Rubyn
   module Commands
     class Refactor < Base
@@ -35,141 +33,18 @@ module Rubyn
           formatter.newline
           formatter.credit_usage(result["credits_used"], nil) if result["credits_used"]
           formatter.newline
-          prompt_apply(file, file_content, full_response, formatter)
+
+          file_blocks = Context::ResponseParser.extract_file_blocks(full_response)
+          if file_blocks.any?
+            applier = Context::FileApplier.new(original_file: file, formatter: formatter)
+            applier.apply(file_blocks)
+          end
         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/context/file_applier.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rubyn
+  module Context
+    class FileApplier
+      def initialize(original_file:, formatter:)
+        @original_file = original_file
+        @formatter = formatter
+      end
+
+      def apply(file_blocks)
+        if file_blocks.length == 1 && file_blocks.first[:path].nil?
+          apply_single(file_blocks.first[:code])
+        else
+          apply_multi(file_blocks)
+        end
+      end
+
+      def new_file?(path)
+        return false unless path
+
+        path != @original_file &&
+          !path.end_with?("/#{@original_file}") &&
+          !@original_file.end_with?("/#{path}")
+      end
+
+      private
+
+      def apply_single(code)
+        print "\nApply changes? (y/n/diff) "
+        choice = $stdin.gets&.strip&.downcase
+
+        case choice
+        when "y"
+          write_file(@original_file, code)
+        when "diff"
+          original_content = File.read(@original_file)
+          Rubyn::Output::DiffRenderer.render(original: original_content, modified: code)
+          print "\nApply changes? (y/n) "
+          write_file(@original_file, code) if $stdin.gets&.strip&.downcase == "y"
+        else
+          @formatter.info("Changes discarded.")
+        end
+      end
+
+      def apply_multi(file_blocks)
+        @formatter.newline
+        @formatter.info("This refactor produces #{file_blocks.length} file(s):")
+        file_blocks.each do |block|
+          path = block[:path] || @original_file
+          label = new_file?(path) ? "NEW" : "MODIFIED"
+          @formatter.info("  [#{label}] #{path}")
+        end
+
+        print "\nApply all changes? (y/n/select) "
+        choice = $stdin.gets&.strip&.downcase
+
+        case choice
+        when "y"
+          file_blocks.each { |block| write_block(block) }
+        when "select"
+          file_blocks.each { |block| apply_selected(block) }
+        else
+          @formatter.info("All changes discarded.")
+        end
+      end
+
+      def apply_selected(block)
+        path = block[:path] || @original_file
+        label = new_file?(path) ? "NEW" : "MODIFIED"
+        print "  Apply [#{label}] #{path}? (y/n/diff) "
+        choice = $stdin.gets&.strip&.downcase
+
+        case choice
+        when "y"
+          write_block(block)
+        when "diff"
+          existing = new_file?(path) ? "" : File.read(resolve_path(block))
+          Rubyn::Output::DiffRenderer.render(original: existing, modified: block[:code])
+          print "  Apply? (y/n) "
+          write_block(block) if $stdin.gets&.strip&.downcase == "y"
+        else
+          @formatter.info("  Skipped #{path}")
+        end
+      end
+
+      def write_block(block)
+        target = resolve_path(block)
+        write_file(target, block[:code])
+      end
+
+      def write_file(path, code)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+        created = !File.exist?(path)
+        File.write(path, code)
+        label = created ? "Created" : "Updated"
+        @formatter.success("#{label} #{path}")
+      end
+
+      def resolve_path(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/context/response_parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rubyn
+  module Context
+    class ResponseParser
+      BOLD_HEADER = /\*\*(?:(?:New|Updated|Modified)\s*(?:file)?:\s*)?([a-zA-Z0-9_\/\.\-]+\.rb)\*\*/i
+      BACKTICK_PATH = /`([a-zA-Z0-9_\/\.\-]+\.rb)`\s*\z/
+      INLINE_COMMENT = /^#\s*([a-zA-Z0-9_\/\.\-]+\.rb)/
+
+      def self.extract_file_blocks(response)
+        new(response).extract
+      end
+
+      def initialize(response)
+        @response = response
+      end
+
+      def extract
+        blocks = []
+        parts = @response.split(/(```ruby\n.*?```)/m)
+
+        parts.each_with_index do |part, i|
+          next unless part.start_with?("```ruby\n")
+
+          code = part.sub(/\A```ruby\n/, "").sub(/```\z/, "")
+          preceding = i > 0 ? parts[i - 1] : ""
+          path = detect_path(preceding, code)
+
+          blocks << { path: path, code: code }
+        end
+
+        blocks
+      end
+
+      private
+
+      def detect_path(preceding_text, code)
+        match_bold_header(preceding_text) ||
+          match_backtick_path(preceding_text) ||
+          match_inline_comment(code)
+      end
+
+      def match_bold_header(text)
+        text.match(BOLD_HEADER)&.[](1)
+      end
+
+      def match_backtick_path(text)
+        text.match(BACKTICK_PATH)&.[](1)
+      end
+
+      def match_inline_comment(code)
+        code.lines.first&.strip&.match(INLINE_COMMENT)&.[](1)
+      end
+    end
+  end
+end

data/lib/rubyn/engine/app/assets/javascripts/rubyn/application.js

@@ -293,22 +293,24 @@
 
     // Build the file-to-code mapping
     // Headers and code blocks are in the same order — zip them together
+    // Determine NEW vs MODIFIED by comparing path against the original file
     var fileChanges = codeBlocks.map(function(code, i) {
       var header = fileHeaders[i];
+      var path = (header && header.path) ? header.path : file;
+      var isNew = !!(path && file && path !== file && path.indexOf(file) === -1 && file.indexOf(path) === -1);
       return {
-        path: header ? header.path : file,
-        tag: header ? header.tag : null,
+        path: path,
+        isNew: isNew,
         code: code
       };
     });
 
-    // Show each code block with its file path, tag, and individual apply button
+    // Show each code block with its file path and NEW badge if applicable
     fileChanges.forEach(function(change, i) {
       html += '<div class="rubyn-code-block">';
       html += '<div class="rubyn-code-block-header">';
-      if (change.tag) {
-        var tagClass = change.tag === "NEW" ? "rubyn-tag-new" : "rubyn-tag-modified";
-        html += '<span class="rubyn-file-tag ' + tagClass + '">' + change.tag + '</span>';
+      if (change.isNew) {
+        html += '<span class="rubyn-file-tag rubyn-tag-new">NEW</span>';
       }
       html += '<span class="rubyn-tool-filepath">' + escapeHtml(change.path) + '</span>';
       html += '<div class="rubyn-code-block-actions">';
@@ -478,14 +480,33 @@
 
   function extractFileHeaders(text) {
     var headers = [];
+    var parts = text.split(/(```ruby\n[\s\S]*?```)/g);
 
-    // Match path headers directly above ```ruby blocks
-    // Handles: `[NEW] path.rb`, `path.rb`, #### path.rb, etc.
-    var regex = /(?:\[NEW\]\s*)?`?([a-zA-Z0-9_\/\.\-]+\.rb)`?\s*\n```ruby/g;
-    var match;
-    while ((match = regex.exec(text)) !== null) {
-      var isNew = match[0].indexOf("[NEW]") !== -1;
-      headers.push({ tag: isNew ? "NEW" : null, path: match[1] });
+    for (var i = 0; i < parts.length; i++) {
+      if (parts[i].indexOf("```ruby\n") !== 0) continue;
+
+      var code = parts[i].replace(/^```ruby\n/, "").replace(/```$/, "");
+      var preceding = i > 0 ? parts[i - 1] : "";
+      var path = null;
+
+      // Strategy 1: Bold header (**New file: path.rb**, **Updated file: path.rb**, **Modified: path.rb**)
+      var boldMatch = preceding.match(/\*\*(?:(?:New|Updated|Modified)\s*(?:file)?:\s*)?([a-zA-Z0-9_\/\.\-]+\.rb)\*\*/i);
+      if (boldMatch) path = boldMatch[1];
+
+      // Strategy 3: Backtick-wrapped path above code block
+      if (!path) {
+        var tickMatch = preceding.match(/`([a-zA-Z0-9_\/\.\-]+\.rb)`\s*$/);
+        if (tickMatch) path = tickMatch[1];
+      }
+
+      // Strategy 4: Path as comment on first line inside code block
+      if (!path) {
+        var firstLine = code.split("\n")[0].trim();
+        var commentMatch = firstLine.match(/^#\s*([a-zA-Z0-9_\/\.\-]+\.rb)/);
+        if (commentMatch) path = commentMatch[1];
+      }
+
+      headers.push({ path: path });
     }
 
     return headers;

data/lib/rubyn/engine/app/assets/stylesheets/rubyn/application.css

@@ -735,6 +735,7 @@ body {
   color: var(--rubyn-success);
 }
 
+
 .rubyn-code-block .rubyn-tool-output {
   margin: 0;
   padding: 1rem;

data/lib/rubyn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubyn
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/rubyn.rb

@@ -52,6 +52,8 @@ require_relative "rubyn/context/project_scanner"
 require_relative "rubyn/context/file_resolver"
 require_relative "rubyn/context/context_builder"
 require_relative "rubyn/context/codebase_indexer"
+require_relative "rubyn/context/response_parser"
+require_relative "rubyn/context/file_applier"
 require_relative "rubyn/output/formatter"
 require_relative "rubyn/output/diff_renderer"
 require_relative "rubyn/output/spinner"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyn
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - matthewsuttles
@@ -297,8 +297,10 @@ files:
 - lib/rubyn/config/settings.rb
 - lib/rubyn/context/codebase_indexer.rb
 - lib/rubyn/context/context_builder.rb
+- lib/rubyn/context/file_applier.rb
 - lib/rubyn/context/file_resolver.rb
 - lib/rubyn/context/project_scanner.rb
+- lib/rubyn/context/response_parser.rb
 - lib/rubyn/engine/app/assets/images/rubyn/RubynLogo.png
 - lib/rubyn/engine/app/assets/javascripts/rubyn/application.js
 - lib/rubyn/engine/app/assets/stylesheets/rubyn/application.css