emerge 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a44399f9df18a4ce4d32984e12eaadb2fa921c34409d8e4daa0dd1b4acddd2c
-  data.tar.gz: 855d965c1478cbc23eee27f5f99281d1a144b7c40197bdb693fac7d93f0be72d
+  metadata.gz: f78e2be6724a6620a5135d20910b99fe76c8a959b00f6703bdad0c0d2c043742
+  data.tar.gz: 8366d036be25ec0b3da721346b1c71dcfcdccd2bf7b7f2bea9f3e6838cf62a8b
 SHA512:
-  metadata.gz: 9d005834cf05f3d463df75af935e5e5ad075fe98cac3a05169df0e9f29c50366731f99b606af924ec33afce6fe332cd0e0ebccdd4768d52fa2dff59628e28b68
-  data.tar.gz: 184aad1844eacdf8aa3693ab5ff45acb36f11a16d039f258137f807f355f822b5f31565450927f5b6db453300785df287dcb5dc7c68227d635ccc7dc498a83ba
+  metadata.gz: 4359ea66070503dc5dc98d1040a39598df3d760bad78393724baa0f689caf18c5e26d2875375ba3751f2fb95d4641e078ff4111084c7acf51b63118955e6a3cc
+  data.tar.gz: 13d4cc4f14a5f6e794592ce12eb5f6acd785fa5d51fbb7d9241e69c78ab7317a5f7b374dbcf06b2bf641cff890b1a7baa941ad3c76f306e207bbc069492875f0

data/README.md

@@ -108,8 +108,33 @@ emerge upload snapshots \
   --project-root /my/awesomeapp/android/repo
 ```
 
-## Building
+## Reaper
 
-This depends on [Tree Sitter](https://tree-sitter.github.io/tree-sitter/) for part of its functionality.
+Experimental support has been added to interactively examine [Reaper](https://docs.emergetools.com/docs/reaper) results and also **delete them from your codebase**.
 
-In order to parse language grammars for Swift and Kotlin, both of which are third-party language grammars, we also depend on [tsdl](https://github.com/stackmystack/tsdl). This downloads and compiles the language grammars into dylibs for us to use.
+Use the `reaper` subcommand to get started, e.g.:
+
+```shell
+emerge reaper --upload-id 40f1dfe7-6c57-47c3-bc52-b621aec0ba8d \
+  --project-root /path/to/your/repo
+```
+
+After which it will prompt you to select classes to delete.
+
+### How it works
+
+Under the hood we are using [Tree Sitter](https://tree-sitter.github.io/tree-sitter/) to parse your source files into an AST which is then used for deletions. There are some obvious limitations to this approach, namely that Tree Sitter is designed for source code editors and only looks at a single file at a time. We are exploring some better long-term approaches but this works well enough for now!
+
+### Supported languages
+
+We currently support the following languages:
+
+- Swift
+- Kotlin
+- Java
+
+Please open an issue if you need an additional language grammar.
+
+### Building
+
+Because many of the language grammars we use are third-party, we have to package them with our CLI tool as shared libraries for distribution. We depend on [tsdl](https://github.com/stackmystack/tsdl) to build the grammars from our `parsers.toml` file.

data/lib/commands/global_options.rb

@@ -9,6 +9,8 @@ module EmergeCLI
       def before(args)
         log_level = args[:debug] ? ::Logger::DEBUG : ::Logger::INFO
         EmergeCLI::Logger.configure(log_level)
+
+        EmergeCLI::Utils::VersionCheck.new.check_version
       end
     end
   end

data/lib/commands/reaper/reaper.rb

@@ -0,0 +1,201 @@
+require 'dry/cli'
+require 'json'
+require 'tty-prompt'
+
+module EmergeCLI
+  module Commands
+    class Reaper < EmergeCLI::Commands::GlobalOptions
+      desc 'Analyze dead code from an Emerge upload'
+
+      option :upload_id, type: :string, required: true, desc: 'Upload ID to analyze'
+      option :project_root, type: :string, required: true,
+                            desc: 'Root directory of the project, defaults to current directory'
+
+      option :api_token, type: :string, required: false,
+                         desc: 'API token for authentication, defaults to ENV[EMERGE_API_TOKEN]'
+
+      option :profile, type: :boolean, default: false, desc: 'Enable performance profiling metrics'
+
+      option :skip_delete_usages, type: :boolean, default: false,
+                                  desc: 'Skip deleting usages of the type (experimental feature)'
+
+      def initialize(network: nil)
+        @network = network
+      end
+
+      def call(**options)
+        @options = options
+        @profiler = EmergeCLI::Profiler.new(enabled: options[:profile])
+        @prompt = TTY::Prompt.new
+        before(options)
+        success = false
+
+        begin
+          api_token = @options[:api_token] || ENV.fetch('EMERGE_API_TOKEN', nil)
+          raise 'API token is required' unless api_token
+
+          @network ||= EmergeCLI::Network.new(api_token:)
+          project_root = @options[:project_root] || Dir.pwd
+
+          Sync do
+            all_data = @profiler.measure('fetch_dead_code') { fetch_all_dead_code(@options[:upload_id]) }
+            result = @profiler.measure('parse_dead_code') { DeadCodeResult.new(all_data) }
+
+            Logger.info result.to_s
+
+            selected_types = prompt_class_selection(result.filtered_unseen_classes, result.metadata['platform'])
+            Logger.info 'Selected classes:'
+            selected_types.each do |selected_class|
+              Logger.info " - #{selected_class['class_name']}"
+            end
+
+            confirmed = confirm_deletion(selected_types.length)
+            if !confirmed
+              Logger.info 'Operation cancelled'
+              return false
+            end
+
+            Logger.info 'Proceeding with deletion...'
+            platform = result.metadata['platform']
+            deleter = EmergeCLI::Reaper::CodeDeleter.new(
+              project_root: project_root,
+              platform: platform,
+              profiler: @profiler,
+              skip_delete_usages: options[:skip_delete_usages]
+            )
+            @profiler.measure('delete_types') { deleter.delete_types(selected_types) }
+          end
+
+          @profiler.report if @options[:profile]
+          success = true
+        rescue StandardError => e
+          Logger.error "Failed to analyze dead code: #{e.message}"
+          raise e
+        ensure
+          @network&.close
+        end
+
+        success
+      end
+
+      private
+
+      def fetch_all_dead_code(upload_id)
+        Logger.info 'Fetching dead code analysis (this may take a while for large codebases)...'
+
+        page = 1
+        combined_data = nil
+
+        loop do
+          response = fetch_dead_code_page(upload_id, page)
+          data = JSON.parse(response.read)
+
+          if combined_data.nil?
+            combined_data = data
+          else
+            combined_data['dead_code'].concat(data.fetch('dead_code', []))
+          end
+
+          current_page = data.dig('pagination', 'current_page')
+          total_pages = data.dig('pagination', 'total_pages')
+
+          break unless current_page && total_pages && current_page < total_pages
+
+          page += 1
+          Logger.info "Fetching page #{page} of #{total_pages}..."
+        end
+
+        combined_data
+      end
+
+      def fetch_dead_code_page(upload_id, page)
+        @network.post(
+          path: '/deadCode/export',
+          query: {
+            uploadId: upload_id,
+            page: page
+          },
+          headers: { 'Accept' => 'application/json' },
+          body: nil
+        )
+      end
+
+      def prompt_class_selection(unseen_classes, platform)
+        return nil if unseen_classes.empty?
+
+        choices = unseen_classes.map do |item|
+          display_name = if item['paths']&.first && platform == 'ios'
+                           "#{item['class_name']} (#{item['paths'].first})"
+                         else
+                           item['class_name']
+                         end
+          {
+            name: display_name,
+            value: item
+          }
+        end
+
+        @prompt.multi_select(
+          'Select classes to delete:'.blue,
+          choices,
+          per_page: 15,
+          echo: false,
+          filter: true,
+          min: 1
+        )
+      end
+
+      def confirm_deletion(count)
+        @prompt.yes?("Are you sure you want to delete #{count} type#{count > 1 ? 's' : ''}?")
+      end
+
+      class DeadCodeResult
+        attr_reader :metadata, :dead_code, :counts, :pagination
+
+        def initialize(data)
+          @metadata = data['metadata']
+          @dead_code = data['dead_code']
+          @counts = data['counts']
+          @pagination = data['pagination']
+        end
+
+        def filtered_unseen_classes
+          @filtered_unseen_classes ||= dead_code
+                                       .reject { |item| item['seen'] }
+                                       .reject do |item|
+            paths = item['paths']
+            next false if paths.nil? || paths.empty?
+
+            next true if paths.any? do |path|
+              path.include?('/SourcePackages/checkouts/') ||
+              path.include?('/Pods/') ||
+              path.include?('/Carthage/') ||
+              path.include?('/Vendor/') ||
+              path.include?('/Sources/') ||
+              path.include?('/DerivedSources/')
+            end
+
+            next false if paths.none? do |path|
+              path.end_with?('.swift', '.java', '.kt')
+            end
+          end
+        end
+
+        def to_s
+          <<~SUMMARY.yellow
+
+            Dead Code Analysis Results:
+            App ID: #{@metadata['app_id']}
+            App Version: #{@metadata['version']}
+            Platform: #{@metadata['platform']}
+
+            Statistics:
+            - Total User Sessions: #{@counts['user_sessions']}
+            - Seen Classes: #{@counts['seen_classes']}
+            - Unseen Classes: #{@counts['unseen_classes']}
+          SUMMARY
+        end
+      end
+    end
+  end
+end

data/lib/emerge_cli.rb

@@ -9,8 +9,10 @@ require_relative 'commands/upload/snapshots/client_libraries/default'
 require_relative 'commands/integrate/fastlane'
 require_relative 'commands/config/snapshots/snapshots_ios'
 require_relative 'commands/config/orderfiles/orderfiles_ios'
+require_relative 'commands/reaper/reaper'
 
 require_relative 'reaper/ast_parser'
+require_relative 'reaper/code_deleter'
 
 require_relative 'utils/git_info_provider'
 require_relative 'utils/git_result'
@@ -20,10 +22,9 @@ require_relative 'utils/logger'
 require_relative 'utils/network'
 require_relative 'utils/profiler'
 require_relative 'utils/project_detector'
+require_relative 'utils/version_check'
 
 require 'dry/cli'
-require 'pry'
-require 'pry-byebug'
 
 module EmergeCLI
   extend Dry::CLI::Registry
@@ -40,6 +41,8 @@ module EmergeCLI
     prefix.register 'snapshots-ios', Commands::Config::SnapshotsIOS
     prefix.register 'order-files-ios', Commands::Config::OrderFilesIOS
   end
+
+  register 'reaper', Commands::Reaper
 end
 
 # By default the log level is INFO, but can be overridden by the --debug flag

data/lib/reaper/ast_parser.rb

@@ -1,6 +1,6 @@
 require 'tree_sitter'
 
-module Emerge
+module EmergeCLI
   module Reaper
     # Parses the AST of a given file using Tree Sitter and allows us to find usages or delete types.
     # This does have a lot of limitations since it only looks at a single file at a time,
@@ -8,7 +8,7 @@ module Emerge
     class AstParser
       DECLARATION_NODE_TYPES = {
         'swift' => %i[class_declaration protocol_declaration],
-        'kotlin' => %i[class_declaration protocol_declaration interface_declaration],
+        'kotlin' => %i[class_declaration protocol_declaration interface_declaration object_declaration],
         'java' => %i[class_declaration protocol_declaration interface_declaration]
       }.freeze
 
@@ -76,6 +76,7 @@ module Emerge
         lines_to_remove = []
 
         while (node = nodes_to_process.shift)
+          Logger.debug "Processing node: #{node.type} #{node_text(node)}"
           if declaration_node_types.include?(node.type)
             type_identifier_node = find_type_identifier(node)
             if type_identifier_node && fully_qualified_type_name(type_identifier_node) == type_name
@@ -95,6 +96,7 @@ module Emerge
 
         lines = file_contents.split("\n")
         lines_to_remove.each do |range|
+          Logger.debug "Removing lines #{range[:start]} to #{range[:end]}"
           (range[:start]..range[:end]).each { |i| lines[i] = nil }
 
           # Remove extra newline after class declaration, but only if it's blank
@@ -107,7 +109,11 @@ module Emerge
         new_tree = @parser.parse_string(nil, modified_source)
 
         return nil if only_comments_and_imports?(TreeSitter::TreeCursor.new(new_tree.root_node))
-        modified_source
+
+        # Preserve original newline state
+        had_final_newline = file_contents.end_with?("\n")
+        modified_source = modified_source.rstrip
+        had_final_newline ? "#{modified_source}\n" : modified_source
       end
 
       # Finds all usages of a given type in a file.
@@ -138,9 +144,42 @@ module Emerge
         usages
       end
 
+      def delete_usage(file_contents:, type_name:)
+        @current_file_contents = file_contents
+        tree = @parser.parse_string(nil, file_contents)
+        cursor = TreeSitter::TreeCursor.new(tree.root_node)
+        nodes_to_process = [cursor.current_node]
+        nodes_to_remove = []
+
+        Logger.debug "Starting to scan for usages of #{type_name}"
+
+        while (node = nodes_to_process.shift)
+          identifier_type = identifier_node_types.include?(node.type)
+          if identifier_type && node_text(node) == type_name
+            Logger.debug "Found usage of #{type_name} in node type: #{node.type}"
+            removable_node = find_removable_parent(node)
+            if removable_node
+              Logger.debug "Will remove parent node of type: #{removable_node.type}"
+              Logger.debug "Node text to remove: #{node_text(removable_node)}"
+              nodes_to_remove << removable_node
+            else
+              Logger.debug 'No suitable parent node found for removal'
+            end
+          end
+
+          node.each { |child| nodes_to_process.push(child) }
+        end
+
+        return file_contents if nodes_to_remove.empty?
+
+        Logger.debug "Found #{nodes_to_remove.length} nodes to remove"
+        remove_nodes_from_content(file_contents, nodes_to_remove)
+      end
+
       private
 
       def remove_node(node, lines_to_remove)
+        Logger.debug "Removing node: #{node.type}"
         start_position = node.start_point.row
         end_position = node.end_point.row
         lines_to_remove << { start: start_position, end: end_position }
@@ -188,6 +227,7 @@ module Emerge
           parent = find_parent_type_declaration(parent)
         end
 
+        Logger.debug "Fully qualified type name: #{class_name}"
         class_name
       end
 
@@ -229,6 +269,151 @@ module Emerge
         end_byte = node.end_byte
         @current_file_contents[start_byte...end_byte]
       end
+
+      def find_removable_parent(node)
+        current = node
+        Logger.debug "Finding removable parent for node type: #{node.type}"
+
+        while current && !current.null?
+          Logger.debug "Checking parent node type: #{current.type}"
+          case current.type
+          when :variable_declaration, # var foo: DeletedType
+               :parameter, # func example(param: DeletedType)
+               :type_annotation, # : DeletedType
+               :argument, # functionCall(param: DeletedType)
+               :import_declaration # import DeletedType
+            Logger.debug "Found removable parent node of type: #{current.type}"
+            return current
+          when :navigation_expression # NetworkDebugger.printStats
+            result = handle_navigation_expression(current)
+            return result if result
+          when :class_declaration, :function_declaration, :method_declaration
+            Logger.debug "Reached structural element, stopping at: #{current.type}"
+            break
+          end
+          current = current.parent
+        end
+
+        Logger.debug 'No better parent found, returning original node'
+        node
+      end
+
+      def handle_navigation_expression(navigation_node)
+        # If this navigation expression is part of a call, remove the entire call
+        parent_call = navigation_node.parent
+        return nil unless parent_call && parent_call.type == :call_expression
+
+        Logger.debug 'Found call expression containing navigation expression'
+        # Check if this call is the only statement in an if condition
+        if_statement = find_parent_if_statement(parent_call)
+        if if_statement && contains_single_statement?(if_statement)
+          Logger.debug 'Found if statement with single call, removing entire if block'
+          return if_statement
+        end
+        parent_call
+      end
+
+      def find_parent_if_statement(node)
+        current = node
+        Logger.debug "Looking for parent if statement starting from node type: #{node.type}"
+        while current && !current.null?
+          Logger.debug "  Checking node type: #{current.type}"
+          if current.type == :if_statement
+            Logger.debug '  Found parent if statement'
+            return current
+          end
+          current = current.parent
+        end
+        Logger.debug '  No parent if statement found'
+        nil
+      end
+
+      def contains_single_statement?(if_statement)
+        Logger.debug 'Checking if statement for single statement'
+        # Find the block/body of the if statement - try different field names based on language
+        block = if_statement.child_by_field_name('consequence') ||
+                if_statement.child_by_field_name('body') ||
+                if_statement.find { |child| child.type == :statements }
+
+        unless block
+          Logger.debug '  No block found in if statement. Node structure:'
+          Logger.debug "  If statement type: #{if_statement.type}"
+          Logger.debug '  Children types:'
+          if_statement.each do |child|
+            Logger.debug "    - #{child.type} (text: #{node_text(child)[0..50]}...)"
+          end
+          return false
+        end
+
+        Logger.debug "  Found block of type: #{block.type}"
+
+        relevant_children = block.reject do |child|
+          %i[comment line_break whitespace].include?(child.type)
+        end
+
+        Logger.debug "  Found #{relevant_children.length} significant children in if block"
+        relevant_children.each do |child|
+          Logger.debug "    Child type: #{child.type}, text: #{node_text(child)[0..50]}..."
+        end
+
+        relevant_children.length == 1
+      end
+
+      def remove_nodes_from_content(content, nodes)
+        # Sort nodes by their position in reverse order to avoid offset issues
+        nodes.sort_by! { |n| -n.start_byte }
+
+        # Check if original file had final newline
+        had_final_newline = content.end_with?("\n")
+
+        # Remove each node and clean up surrounding blank lines
+        modified_contents = content.dup
+        nodes.each do |node|
+          modified_contents = remove_single_node(modified_contents, node)
+        end
+
+        # Restore the original newline state at the end of the file
+        modified_contents.chomp!
+        had_final_newline ? "#{modified_contents}\n" : modified_contents
+      end
+
+      def remove_single_node(content, node)
+        had_final_newline = content.end_with?("\n")
+
+        # Remove the node's content
+        start_byte = node.start_byte
+        end_byte = node.end_byte
+        Logger.debug "Removing text: #{content[start_byte...end_byte]}"
+        content[start_byte...end_byte] = ''
+
+        # Clean up any blank lines created by the removal
+        content = cleanup_blank_lines(content, node.start_point.row, node.end_point.row)
+
+        had_final_newline ? "#{content}\n" : content
+      end
+
+      def cleanup_blank_lines(content, start_line, end_line)
+        lines = content.split("\n")
+
+        # Check for consecutive blank lines around the removed content
+        lines[start_line - 1] = nil if consecutive_blank_lines?(lines, start_line, end_line)
+
+        # Remove any blank lines left in the removed node's place
+        (start_line..end_line).each do |i|
+          lines[i] = nil if lines[i]&.match?(/^\s*$/)
+        end
+
+        lines.compact.join("\n")
+      end
+
+      def consecutive_blank_lines?(lines, start_line, end_line)
+        return false unless start_line > 0 && end_line + 1 < lines.length
+
+        prev_line = lines[start_line - 1]
+        next_line = lines[end_line + 1]
+
+        prev_line&.match?(/^\s*$/) && next_line&.match?(/^\s*$/)
+      end
     end
   end
 end

data/lib/reaper/code_deleter.rb

@@ -0,0 +1,263 @@
+require 'xcodeproj'
+
+module EmergeCLI
+  module Reaper
+    class CodeDeleter
+      def initialize(project_root:, platform:, profiler:, skip_delete_usages: false)
+        @project_root = File.expand_path(project_root)
+        @platform = platform
+        @profiler = profiler
+        @skip_delete_usages = skip_delete_usages
+        Logger.debug "Initialized CodeDeleter with project root: #{@project_root}, platform: #{@platform}"
+      end
+
+      def delete_types(types)
+        Logger.debug "Project root: #{@project_root}"
+
+        types.each do |class_info|
+          Logger.info "Deleting #{class_info['class_name']}"
+
+          type_name = parse_type_name(class_info['class_name'])
+          Logger.debug "Parsed type name: #{type_name}"
+
+          # Remove line number from path if present
+          paths = class_info['paths']&.map { |path| path.sub(/:\d+$/, '') }
+          found_usages = @profiler.measure('find_type_in_project') do
+            find_type_in_project(type_name)
+          end
+
+          if paths.nil? || paths.empty?
+            Logger.info "No paths provided for #{type_name}, using found usages instead..."
+            paths = found_usages
+                    .select { |usage| usage[:usages].any? { |u| u[:usage_type] == 'declaration' } }
+                    .map { |usage| usage[:path] }
+            if paths.empty?
+              Logger.warn "Could not find any files containing #{type_name}"
+              next
+            end
+            Logger.info "Found #{type_name} in: #{paths.join(', ')}"
+          end
+
+          # First pass: Delete declarations
+          paths.each do |path|
+            Logger.debug "Processing path: #{path}"
+            @profiler.measure('delete_type_from_file') do
+              delete_type_from_file(path, type_name)
+            end
+          end
+
+          # Second pass: Delete remaining usages (unless skipped)
+          if @skip_delete_usages
+            Logger.info 'Skipping delete usages'
+          else
+            identifier_usages = found_usages.select do |usage|
+              usage[:usages].any? { |u| u[:usage_type] == 'identifier' }
+            end
+            identifier_usage_paths = identifier_usages.map { |usage| usage[:path] }.uniq
+            if identifier_usage_paths.empty?
+              Logger.info 'No identifier usages found, skipping delete usages'
+            else
+              identifier_usage_paths.each do |path|
+                Logger.debug "Processing usages in path: #{path}"
+                @profiler.measure('delete_usages_from_file') do
+                  delete_usages_from_file(path, type_name)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def parse_type_name(type_name)
+        # Remove first module prefix for Swift types if present
+        if @platform == 'ios' && type_name.include?('.')
+          type_name.split('.')[1..].join('.')
+        # For Android, strip package name and just use the class name
+        elsif @platform == 'android' && type_name.include?('.')
+          # rubocop:disable Layout/LineLength
+          # Handle cases like "com.emergetools.hackernews.data.remote.ItemResponse $NullResponse (HackerNewsBaseClient.kt)"
+          # rubocop:enable Layout/LineLength
+          has_nested_class = type_name.include?('$')
+          parts = type_name.split
+          if parts.length == 0
+            type_name
+          elsif has_nested_class && parts.length > 1
+            base_name = parts[0].split('.').last
+            nested_class = parts[1].match(/\$(.+)/).captures.first
+            "#{base_name}.#{nested_class}"
+          else
+            parts[0].split('.').last
+          end
+        else
+          type_name
+        end
+      end
+
+      def delete_type_from_file(path, type_name)
+        full_path = resolve_file_path(path)
+        return unless full_path
+
+        Logger.debug "Processing file: #{full_path}"
+        begin
+          original_contents = @profiler.measure('read_file') { File.read(full_path) }
+          parser = make_parser_for_file(full_path)
+          modified_contents = @profiler.measure('parse_and_delete_type') do
+            parser.delete_type(
+              file_contents: original_contents,
+              type_name: type_name
+            )
+          end
+
+          if modified_contents.nil?
+            @profiler.measure('delete_file') do
+              File.delete(full_path)
+            end
+            if parser.language == 'swift'
+              @profiler.measure('delete_type_from_xcode_project') do
+                delete_type_from_xcode_project(full_path)
+              end
+            end
+            Logger.info "Deleted file #{full_path} as it only contained #{type_name}"
+          elsif modified_contents != original_contents
+            @profiler.measure('write_file') do
+              File.write(full_path, modified_contents)
+            end
+            Logger.info "Successfully deleted #{type_name} from #{full_path}"
+          else
+            Logger.warn "No changes made to #{full_path} for #{type_name}"
+          end
+        rescue StandardError => e
+          Logger.error "Failed to delete #{type_name} from #{full_path}: #{e.message}"
+          Logger.error e.backtrace.join("\n")
+        end
+      end
+
+      def delete_type_from_xcode_project(file_path)
+        xcodeproj_path = Dir.glob(File.join(@project_root, '**/*.xcodeproj')).first
+        if xcodeproj_path.nil?
+          Logger.warn "No Xcode project found in #{@project_root}"
+          return
+        end
+
+        begin
+          project = Xcodeproj::Project.open(xcodeproj_path)
+          relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(@project_root)).to_s
+
+          file_ref = project.files.find { |f| f.real_path.to_s.end_with?(relative_path) }
+          if file_ref
+            file_ref.remove_from_project
+            project.save
+            Logger.info "Removed #{relative_path} from Xcode project"
+          else
+            Logger.warn "Could not find #{relative_path} in Xcode project"
+          end
+        rescue StandardError => e
+          Logger.error "Failed to update Xcode project: #{e.message}"
+          Logger.error e.backtrace.join("\n")
+        end
+      end
+
+      def find_type_in_project(type_name)
+        found_usages = []
+        source_patterns = case @platform&.downcase
+                          when 'ios'
+                            { 'swift' => '**/*.swift' }
+                          when 'android'
+                            {
+                              'kotlin' => '**/*.kt',
+                              'java' => '**/*.java'
+                            }
+                          else
+                            raise "Unsupported platform: #{@platform}"
+                          end
+
+        source_patterns.each do |language, pattern|
+          Dir.glob(File.join(@project_root, pattern)).reject { |path| path.include?('/build/') }.each do |file_path|
+            Logger.debug "Scanning #{file_path} for #{type_name}"
+            contents = File.read(file_path)
+            parser = make_parser_for_file(file_path)
+            usages = parser.find_usages(file_contents: contents, type_name: type_name)
+
+            if usages.any?
+              Logger.debug "✅ Found #{type_name} in #{file_path}"
+              relative_path = Pathname.new(file_path).relative_path_from(Pathname.new(@project_root)).to_s
+              found_usages << {
+                path: relative_path,
+                usages: usages,
+                language: language
+              }
+            end
+          rescue StandardError => e
+            Logger.warn "Error scanning #{file_path}: #{e.message}"
+          end
+        end
+
+        found_usages
+      end
+
+      def delete_usages_from_file(path, type_name)
+        full_path = resolve_file_path(path)
+        return unless full_path
+
+        begin
+          original_contents = File.read(full_path)
+          parser = make_parser_for_file(full_path)
+          Logger.debug "Deleting usages of #{type_name} from #{full_path}"
+          modified_contents = parser.delete_usage(
+            file_contents: original_contents,
+            type_name: type_name
+          )
+
+          if modified_contents != original_contents
+            File.write(full_path, modified_contents)
+            Logger.info "Successfully removed usages of #{type_name} from #{full_path}"
+          end
+        rescue StandardError => e
+          Logger.error "Failed to delete usages of #{type_name} from #{full_path}: #{e.message}"
+          Logger.error e.backtrace.join("\n")
+        end
+      end
+
+      def resolve_file_path(path)
+        # If path starts with /, treat it as relative to project root
+        if path.start_with?('/')
+          path = path[1..] # Remove leading slash
+          full_path = File.join(@project_root, path)
+          return full_path if File.exist?(full_path)
+        end
+
+        # Try direct path first
+        full_path = File.join(@project_root, path)
+        return full_path if File.exist?(full_path)
+
+        # If not found, search recursively
+        Logger.debug "File not found at #{full_path}, searching in project..."
+        matching_files = Dir.glob(File.join(@project_root, '**', path))
+                            .reject { |p| p.include?('/build/') }
+
+        if matching_files.empty?
+          Logger.warn "Could not find #{path} in project"
+          return nil
+        elsif matching_files.length > 1
+          Logger.warn "Found multiple matches for #{path}: #{matching_files.join(', ')}"
+          Logger.warn "Using first match: #{matching_files.first}"
+        end
+
+        matching_files.first
+      end
+
+      def make_parser_for_file(file_path)
+        language = case File.extname(file_path)
+                   when '.swift' then 'swift'
+                   when '.kt' then 'kotlin'
+                   when '.java' then 'java'
+                   else
+                     raise "Unsupported file type for #{file_path}"
+                   end
+        AstParser.new(language)
+      end
+    end
+  end
+end

data/lib/utils/network.rb

@@ -11,7 +11,7 @@ module EmergeCLI
     RETRY_DELAY = 5
     MAX_RETRIES = 3
 
-    def initialize(api_token:, base_url: EMERGE_API_PROD_URL)
+    def initialize(api_token: nil, base_url: EMERGE_API_PROD_URL)
       @base_url = base_url
       @api_token = api_token
       @internet = Async::HTTP::Internet.new
@@ -21,8 +21,8 @@ module EmergeCLI
       request(:get, path, nil, headers)
     end
 
-    def post(path:, body:, headers: {})
-      request(:post, path, body, headers)
+    def post(path:, body:, headers: {}, query: nil)
+      request(:post, path, body, headers, query)
     end
 
     def put(path:, body:, headers: {})
@@ -35,18 +35,23 @@ module EmergeCLI
 
     private
 
-    def request(method, path, body, custom_headers)
+    def request(method, path, body, custom_headers, query = nil)
       uri = if path.start_with?('http')
               URI.parse(path)
             else
-              URI::HTTPS.build(host: @base_url, path:)
+              query_string = query ? URI.encode_www_form(query) : nil
+              URI::HTTPS.build(
+                host: @base_url,
+                path: path,
+                query: query_string
+              )
             end
       absolute_uri = uri.to_s
 
       headers = {
-        'X-API-Token' => @api_token,
         'User-Agent' => "emerge-cli/#{EmergeCLI::VERSION}"
       }
+      headers['X-API-Token'] = @api_token if @api_token
       headers['Content-Type'] = 'application/json' if method == :post && body.is_a?(Hash)
       headers.merge!(custom_headers)
 

data/lib/utils/version_check.rb

@@ -0,0 +1,32 @@
+require 'json'
+
+module EmergeCLI
+  module Utils
+    class VersionCheck
+      def initialize(network: EmergeCLI::Network.new)
+        @network = network
+      end
+
+      def check_version
+        Sync do
+          response = @network.get(
+            path: 'https://rubygems.org/api/v1/gems/emerge.json',
+            headers: {}
+          )
+          latest_version = JSON.parse(response.read).fetch('version')
+          current_version = EmergeCLI::VERSION
+
+          if Gem::Version.new(latest_version) > Gem::Version.new(current_version)
+            Logger.warn "A new version of emerge-cli is available (#{latest_version})"
+            Logger.warn "You are currently using version #{current_version}"
+            Logger.warn "To update, run: gem update emerge\n"
+          end
+        end
+      rescue KeyError
+        Logger.error 'Failed to parse version from RubyGems API response'
+      rescue StandardError => e
+        Logger.error "Failed to check for updates: #{e.message}"
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module EmergeCLI
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.3.0'.freeze
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: emerge
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Emerge Tools
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-12-02 00:00:00.000000000 Z
+date: 2024-12-13 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: async
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.21.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.21.1
 - !ruby/object:Gem::Dependency
   name: async-http
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +66,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.1
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.8'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: ruby_tree_sitter
   requirement: !ruby/object:Gem::Requirement
@@ -165,6 +137,7 @@ files:
 - lib/commands/config/snapshots/snapshots_ios.rb
 - lib/commands/global_options.rb
 - lib/commands/integrate/fastlane.rb
+- lib/commands/reaper/reaper.rb
 - lib/commands/upload/snapshots/client_libraries/default.rb
 - lib/commands/upload/snapshots/client_libraries/paparazzi.rb
 - lib/commands/upload/snapshots/client_libraries/roborazzi.rb
@@ -172,6 +145,7 @@ files:
 - lib/commands/upload/snapshots/snapshots.rb
 - lib/emerge_cli.rb
 - lib/reaper/ast_parser.rb
+- lib/reaper/code_deleter.rb
 - lib/utils/git.rb
 - lib/utils/git_info_provider.rb
 - lib/utils/git_result.rb
@@ -180,7 +154,14 @@ files:
 - lib/utils/network.rb
 - lib/utils/profiler.rb
 - lib/utils/project_detector.rb
+- lib/utils/version_check.rb
 - lib/version.rb
+- parsers/libtree-sitter-java-darwin-arm64.dylib
+- parsers/libtree-sitter-java-linux-x86_64.so
+- parsers/libtree-sitter-kotlin-darwin-arm64.dylib
+- parsers/libtree-sitter-kotlin-linux-x86_64.so
+- parsers/libtree-sitter-swift-darwin-arm64.dylib
+- parsers/libtree-sitter-swift-linux-x86_64.so
 homepage: https://github.com/EmergeTools/emerge-cli
 licenses:
 - MIT
@@ -204,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: Emerge CLI