mbeditor 0.5.3 → 0.7.1

data/app/controllers/mbeditor/editors_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "digest"
 require "fileutils"
 require "open3"
 require "shellwords"
@@ -14,8 +15,6 @@ module Mbeditor
     before_action :verify_mbeditor_client, unless: -> { request.get? || request.head? }
 
     IMAGE_EXTENSIONS = %w[png jpg jpeg gif svg ico webp bmp avif].freeze
-    MAX_OPEN_FILE_SIZE_BYTES = 5 * 1024 * 1024
-    RG_AVAILABLE = system("which rg > /dev/null 2>&1")
 
     # GET /mbeditor — renders the IDE shell
     def index
@@ -33,11 +32,11 @@ module Mbeditor
       render json: {
         rootName: workspace_root.basename.to_s,
         rootPath: workspace_root.to_s,
-        rubocopAvailable: rubocop_available?,
+        rubocopAvailable: AvailabilityProbe.rubocop(workspace_root),
         rubocopConfigPath: rubocop_config_path,
-        hamlLintAvailable: haml_lint_available?,
-        gitAvailable: git_available?,
-        blameAvailable: git_blame_available?,
+        hamlLintAvailable: AvailabilityProbe.haml_lint(workspace_root),
+        gitAvailable: AvailabilityProbe.git(workspace_root),
+        blameAvailable: AvailabilityProbe.git(workspace_root),
         redmineEnabled: Mbeditor.configuration.redmine_enabled == true,
         testAvailable: test_available?,
         actionCableEnabled: action_cable_enabled?
@@ -46,67 +45,40 @@ module Mbeditor
 
     # GET /mbeditor/files — recursive file tree
     def files
-      root = workspace_root.to_s
-      cached = cached_file_tree(root)
-      return render json: cached if cached
-
-      tree = build_tree(root)
-      store_file_tree(root, tree)
-      render json: tree
+      render json: FileTreeService.build(workspace_root)
     end
 
     # GET /mbeditor/state — load workspace state
     def state
-      path = workspace_root.join("tmp", "mbeditor_workspace.json")
-      if File.exist?(path)
-        render json: JSON.parse(File.read(path))
-      else
-        render json: {}
-      end
-    rescue Errno::ENOENT
-      render json: {}
-    rescue JSON::ParserError
-      render json: {}
+      render json: editor_state_service.read_state
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
 
-    STATE_MAX_BYTES = 1 * 1024 * 1024
+    STATE_MAX_BYTES = EditorStateService::STATE_MAX_BYTES
 
     # POST /mbeditor/state — save workspace state
     def save_state
       raw = params[:state]
       raw = raw.to_unsafe_h if raw.respond_to?(:to_unsafe_h)
-      payload = raw.to_json
-      return render json: { error: "State payload too large" }, status: :content_too_large if payload.bytesize > STATE_MAX_BYTES
-
-      path = workspace_root.join("tmp", "mbeditor_workspace.json")
-      FileUtils.mkdir_p(workspace_root.join("tmp"))
-      File.open(path, File::RDWR | File::CREAT) do |f|
-        f.flock(File::LOCK_EX)
-        f.truncate(0)
-        f.rewind
-        f.write(payload)
-      end
+      editor_state_service.write_state(raw)
       render json: { ok: true }
+    rescue EditorStateService::PayloadTooLargeError
+      render json: { error: "State payload too large" }, status: :content_too_large
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
 
-    SAFE_BRANCH_NAME = /\A[a-zA-Z0-9._\-\/]+\z/
+    HISTORY_MAX_OPS        = 10_000
+    HISTORY_COMPACT_TARGET = 5_000
+
 
     # GET /mbeditor/branch_state?branch=... — load per-branch pane state
     def branch_state
       branch = sanitize_branch_name(params[:branch])
       return render json: {}, status: :bad_request unless branch
 
-      path = workspace_root.join("tmp", "mbeditor_branch_states.json")
-      if File.exist?(path)
-        all = JSON.parse(File.read(path))
-        render json: (all[branch] || {})
-      else
-        render json: {}
-      end
+      render json: editor_state_service.read_branch_state(branch)
     rescue StandardError
       render json: {}
     end
@@ -115,50 +87,114 @@ module Mbeditor
       return render json: { error: "Invalid branch name" }, status: :bad_request unless branch
 
       payload = params[:state].to_unsafe_h
-      return render json: { error: "State payload too large" }, status: :content_too_large if payload.to_json.bytesize > STATE_MAX_BYTES
-
-      path = workspace_root.join("tmp", "mbeditor_branch_states.json")
-      FileUtils.mkdir_p(workspace_root.join("tmp"))
-      File.open(path, File::RDWR | File::CREAT) do |f|
-        f.flock(File::LOCK_EX)
-        existing = f.size > 0 ? JSON.parse(f.read) : {}
-        existing[branch] = payload
-        f.truncate(0)
-        f.rewind
-        f.write(existing.to_json)
-      end
+      editor_state_service.write_branch_state(branch, payload)
       render json: { ok: true }
+    rescue EditorStateService::PayloadTooLargeError
+      render json: { error: "State payload too large" }, status: :content_too_large
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
 
     # POST /mbeditor/prune_branch_states — remove states for deleted branches
     def prune_branch_states
-      state_path = workspace_root.join("tmp", "mbeditor_branch_states.json")
-      return render json: { pruned: [] } unless File.exist?(state_path)
-
       root = workspace_root.to_s
       out, _err, status = Open3.capture3("git", "-C", root, "branch", "--format=%(refname:short)")
       return render json: { pruned: [] } unless status.success?
 
       local_branches = out.split("\n").map(&:strip).reject(&:empty?)
-      pruned = []
-      File.open(state_path, File::RDWR) do |f|
-        f.flock(File::LOCK_EX)
-        all = JSON.parse(f.read) rescue {}
-        pruned = all.keys - local_branches
-        if pruned.any?
-          pruned.each { |b| all.delete(b) }
-          f.truncate(0)
-          f.rewind
-          f.write(all.to_json)
+      pruned = editor_state_service.prune_branch_states(active_branches: local_branches)
+
+      hist_dir = workspace_root.join('tmp', 'mbeditor_history')
+      if File.directory?(hist_dir)
+        Dir.glob(File.join(hist_dir, '*.json')) do |hist_file|
+          data = JSON.parse(File.read(hist_file)) rescue nil
+          next unless data.is_a?(Hash) && data['branch']
+          FileUtils.rm_f(hist_file) unless local_branches.include?(data['branch'])
         end
       end
+
       render json: { pruned: pruned }
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
 
+    # GET /mbeditor/file_history?branch=X&path=Y
+    def file_history
+      branch = sanitize_branch_name(params[:branch])
+      return render json: {}, status: :bad_request unless branch
+
+      path = resolve_path(params[:path])
+      return render json: {}, status: :forbidden unless path
+
+      rel  = relative_path(path)
+      hist = history_file_path(branch, rel)
+      return render json: {} unless File.exist?(hist)
+
+      data = JSON.parse(File.read(hist))
+
+      if data['t']
+        age = Time.now.utc - Time.parse(data['t'])
+        if age > 7 * 24 * 3600
+          FileUtils.rm_f(hist)
+          return render json: {}
+        end
+      end
+
+      render json: { base: data['base'], ops: data['ops'] || [] }
+    rescue JSON::ParserError
+      FileUtils.rm_f(hist) rescue nil
+      render json: {}
+    rescue StandardError
+      render json: {}
+    end
+
+    # POST /mbeditor/file_history
+    def save_file_history
+      branch = sanitize_branch_name(params[:branch])
+      return render json: { error: 'Invalid branch name' }, status: :bad_request unless branch
+
+      path = resolve_path(params[:path])
+      return render json: { error: 'Forbidden' }, status: :forbidden unless path
+
+      rel      = relative_path(path)
+      new_ops  = params[:ops]
+      return render json: { error: 'ops must be an array' }, status: :bad_request unless new_ops.is_a?(Array)
+      return head :no_content if new_ops.empty?
+
+      new_ops_clean = new_ops.map { |op| Array(op).first(5) }
+
+      hist = history_file_path(branch, rel)
+      FileUtils.mkdir_p(File.dirname(hist))
+
+      File.open(hist, File::RDWR | File::CREAT) do |f|
+        f.flock(File::LOCK_EX)
+        existing = f.size > 0 ? (JSON.parse(f.read) rescue {}) : {}
+
+        if existing.empty?
+          base = params[:base].to_s
+          return render json: { error: 'base required for initial history' }, status: :bad_request if base.empty?
+          return render json: { error: 'base too large' }, status: :content_too_large if base.bytesize > STATE_MAX_BYTES
+          existing = { 'branch' => branch, 'path' => rel, 'base' => base, 'ops' => [], 't' => Time.now.utc.iso8601 }
+        end
+
+        existing['ops'] = (existing['ops'] || []) + new_ops_clean
+        existing['t']   = Time.now.utc.iso8601
+
+        if existing['ops'].length > HISTORY_MAX_OPS
+          to_compact       = existing['ops'].shift(HISTORY_COMPACT_TARGET)
+          existing['base'] = compact_history_ops(existing['base'], to_compact)
+        end
+
+        f.truncate(0)
+        f.rewind
+        f.write(existing.to_json)
+      end
+
+      head :no_content
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
     # GET /mbeditor/file?path=...
     def show
       path = resolve_path(params[:path])
@@ -194,7 +230,7 @@ module Mbeditor
       end
 
       size = File.size(path)
-      return render_file_too_large(size) if size > MAX_OPEN_FILE_SIZE_BYTES
+      return render_file_too_large(size) if size > FileOperationService::MAX_FILE_SIZE_BYTES
 
       if image_path?(path)
         return render json: {
@@ -223,7 +259,7 @@ module Mbeditor
       return render json: { error: "Not found" }, status: :not_found unless File.file?(path)
 
       size = File.size(path)
-      return render_file_too_large(size) if size > MAX_OPEN_FILE_SIZE_BYTES
+      return render_file_too_large(size) if size > FileOperationService::MAX_FILE_SIZE_BYTES
 
       send_file path, disposition: "inline"
     end
@@ -234,12 +270,11 @@ module Mbeditor
       return render json: { error: "Forbidden" }, status: :forbidden unless path
       return render json: { error: "Cannot write to this path" }, status: :forbidden if path_blocked_for_operations?(path)
 
-      content = params[:code].to_s
-      return render_file_too_large(content.bytesize) if content.bytesize > MAX_OPEN_FILE_SIZE_BYTES
-
-      File.write(path, content)
+      result = FileOperationService.new(workspace_root).save(path, params[:code].to_s)
       broadcast_files_changed
-      render json: { ok: true, path: relative_path(path) }
+      render json: result
+    rescue FileOperationService::FileTooLargeError
+      render_file_too_large(params[:code].to_s.bytesize)
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -249,16 +284,14 @@ module Mbeditor
       path = resolve_path(params[:path])
       return render json: { error: "Forbidden" }, status: :forbidden unless path
       return render json: { error: "Cannot create file in this path" }, status: :forbidden if path_blocked_for_operations?(path)
-      return render json: { error: "File already exists" }, status: :unprocessable_content if File.exist?(path)
-
-      content = params[:code].to_s
-      return render_file_too_large(content.bytesize) if content.bytesize > MAX_OPEN_FILE_SIZE_BYTES
 
-      FileUtils.mkdir_p(File.dirname(path))
-      File.write(path, content)
+      result = FileOperationService.new(workspace_root).create_file(path, params[:code].to_s)
       broadcast_files_changed
-
-      render json: { ok: true, type: "file", path: relative_path(path), name: File.basename(path) }
+      render json: result
+    rescue FileOperationService::FileExistsError
+      render json: { error: "File already exists" }, status: :unprocessable_content
+    rescue FileOperationService::FileTooLargeError
+      render_file_too_large(params[:code].to_s.bytesize)
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -268,11 +301,12 @@ module Mbeditor
       path = resolve_path(params[:path])
       return render json: { error: "Forbidden" }, status: :forbidden unless path
       return render json: { error: "Cannot create directory in this path" }, status: :forbidden if path_blocked_for_operations?(path)
-      return render json: { error: "Path already exists" }, status: :unprocessable_content if File.exist?(path)
 
-      FileUtils.mkdir_p(path)
+      result = FileOperationService.new(workspace_root).create_dir(path)
       broadcast_files_changed
-      render json: { ok: true, type: "folder", path: relative_path(path), name: File.basename(path) }
+      render json: result
+    rescue FileOperationService::FileExistsError
+      render json: { error: "Path already exists" }, status: :unprocessable_content
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -282,20 +316,15 @@ module Mbeditor
       old_path = resolve_path(params[:path])
       new_path = resolve_path(params[:new_path])
       return render json: { error: "Forbidden" }, status: :forbidden unless old_path && new_path
-      return render json: { error: "Path not found" }, status: :not_found unless File.exist?(old_path)
-      return render json: { error: "Target path already exists" }, status: :unprocessable_content if File.exist?(new_path)
       return render json: { error: "Cannot rename this path" }, status: :forbidden if path_blocked_for_operations?(old_path) || path_blocked_for_operations?(new_path)
 
-      FileUtils.mkdir_p(File.dirname(new_path))
-      FileUtils.mv(old_path, new_path)
+      result = FileOperationService.new(workspace_root).rename(old_path, new_path)
       broadcast_files_changed
-
-      render json: {
-        ok: true,
-        oldPath: relative_path(old_path),
-        path: relative_path(new_path),
-        name: File.basename(new_path)
-      }
+      render json: result
+    rescue FileOperationService::PathNotFoundError
+      render json: { error: "Path not found" }, status: :not_found
+    rescue FileOperationService::TargetExistsError
+      render json: { error: "Target path already exists" }, status: :unprocessable_content
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -304,19 +333,11 @@ module Mbeditor
     def destroy_path
       path = resolve_path(params[:path])
       return render json: { error: "Forbidden" }, status: :forbidden unless path
-      # Idempotent: if already gone the desired state is already achieved.
-      return render json: { ok: true } unless File.exist?(path)
-      return render json: { error: "Cannot delete this path" }, status: :forbidden if path_blocked_for_operations?(path)
-
-      if File.directory?(path)
-        FileUtils.rm_rf(path)
-        broadcast_files_changed
-        render json: { ok: true, type: "folder", path: relative_path(path) }
-      else
-        File.delete(path)
-        broadcast_files_changed
-        render json: { ok: true, type: "file", path: relative_path(path) }
-      end
+      return render json: { error: "Cannot delete this path" }, status: :forbidden if File.exist?(path) && path_blocked_for_operations?(path)
+
+      result = FileOperationService.new(workspace_root).destroy_path(path)
+      broadcast_files_changed if result.key?(:type)
+      render json: result
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -333,12 +354,12 @@ module Mbeditor
 
       results = case language
                 when "ruby"
+                  excl_patterns = Array(Mbeditor.configuration.excluded_paths).map(&:to_s).reject(&:blank?)
                   workspace = RubyDefinitionService.call(
                     workspace_root,
                     symbol,
-                    excluded_dirnames: excluded_dirnames,
-                    excluded_paths:    excluded_paths,
-                    included_dirs:     ruby_def_include_dirs
+                    excluded_paths: excl_patterns,
+                    included_dirs:  ruby_def_include_dirs
                   )
                   ri = RiDefinitionService.call(symbol)
                   workspace + ri
@@ -351,6 +372,34 @@ module Mbeditor
       render json: { error: e.message }, status: :unprocessable_content
     end
 
+    # GET /mbeditor/js_definition?symbol=ReactWindow
+    # Searches workspace JS/JSX/TS/TSX files for global definitions of the named symbol.
+    def js_definition
+      symbol = params[:symbol].to_s.strip
+      return render json: { results: [] } if symbol.blank?
+      return render json: { error: "Invalid symbol" }, status: :bad_request \
+        unless symbol.match?(/\A[a-zA-Z_$][a-zA-Z0-9_$]{0,59}\z/)
+
+      results = JsDefinitionService.new(symbol, workspace_root).call
+      render json: { results: results }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/js_members?symbol=ReactWindow
+    # Searches workspace JS/JSX/TS/TSX files for properties/methods of the named global.
+    def js_members
+      symbol = params[:symbol].to_s.strip
+      return render json: { members: [] } if symbol.blank?
+      return render json: { error: "Invalid symbol" }, status: :bad_request \
+        unless symbol.match?(/\A[a-zA-Z_$][a-zA-Z0-9_$]{0,59}\z/)
+
+      members = JsMembersService.new(symbol, workspace_root).call
+      render json: { symbol: symbol, members: members }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
     # GET /mbeditor/module_members?name=ArticlesHelper
     # Returns methods defined in the workspace file that defines the named module/class.
     def module_members
@@ -358,11 +407,11 @@ module Mbeditor
       return render json: { error: "Invalid name" }, status: :bad_request \
         unless name.match?(/\A[A-Z][a-zA-Z0-9_]*\z/)
 
+      excl_patterns = Array(Mbeditor.configuration.excluded_paths).map(&:to_s).reject(&:blank?)
       file = RubyDefinitionService.module_defined_in(
         workspace_root, name,
-        excluded_dirnames: excluded_dirnames,
-        excluded_paths:    excluded_paths,
-        included_dirs:     ruby_def_include_dirs
+        excluded_paths: excl_patterns,
+        included_dirs:  ruby_def_include_dirs
       )
       return render json: { name: name, methods: [] } unless file
 
@@ -381,20 +430,13 @@ module Mbeditor
       path = resolve_path(params[:path])
       return render json: { error: "Forbidden" }, status: :forbidden unless path
 
-      # Ensure workspace is scanned so include_calls are populated in the cache.
-      # Fast no-op on subsequent calls (mtime checks only).
-      RubyDefinitionService.scan(workspace_root,
-                                 excluded_dirnames: excluded_dirnames,
-                                 excluded_paths:    excluded_paths,
-                                 included_dirs:     ruby_def_include_dirs)
-
+      excl_patterns = Array(Mbeditor.configuration.excluded_paths).map(&:to_s).reject(&:blank?)
       module_names = RubyDefinitionService.includes_in_file(path)
       includes = module_names.filter_map do |mod_name|
         mod_file = RubyDefinitionService.module_defined_in(
           workspace_root, mod_name,
-          excluded_dirnames: excluded_dirnames,
-          excluded_paths:    excluded_paths,
-          included_dirs:     ruby_def_include_dirs
+          excluded_paths: excl_patterns,
+          included_dirs:  ruby_def_include_dirs
         )
         next unless mod_file
 
@@ -409,22 +451,6 @@ module Mbeditor
       render json: { error: e.message }, status: :unprocessable_content
     end
 
-    # GET /mbeditor/unused_methods?path=app/models/article.rb
-    # Returns method names defined in the file that have no call-sites in the workspace.
-    def unused_methods
-      path = resolve_path(params[:path])
-      return render json: { error: "Forbidden" }, status: :forbidden unless path
-
-      unused = UnusedMethodsService.call(
-        workspace_root, path,
-        excluded_dirnames: excluded_dirnames,
-        excluded_paths:    excluded_paths
-      )
-      render json: { unused: unused }
-    rescue StandardError => e
-      render json: { error: e.message }, status: :unprocessable_content
-    end
-
     # GET /mbeditor/search?q=...&offset=0&limit=50&regex=false&match_case=false&whole_word=false
     def search
       query      = params[:q].to_s.strip
@@ -439,9 +465,9 @@ module Mbeditor
       return render json: { error: "Query too long" }, status: :bad_request if query.length > 500
 
       # On first page, count total matches in parallel with fetching results.
-      count_thread = offset == 0 ? Thread.new { count_search_results(query, use_regex: use_regex, match_case: match_case, whole_word: whole_word) } : nil
+      count_thread = offset == 0 ? Thread.new { SearchReplaceService.count(workspace_root, query, use_regex: use_regex, match_case: match_case, whole_word: whole_word, excluded_paths: Mbeditor.configuration.excluded_paths) } : nil
 
-      results   = stream_search_results(query, needed, use_regex: use_regex, match_case: match_case, whole_word: whole_word)
+      results   = SearchReplaceService.search(workspace_root, query, limit: needed, use_regex: use_regex, match_case: match_case, whole_word: whole_word, excluded_paths: Mbeditor.configuration.excluded_paths)
       has_more  = results.length > offset + limit
       response  = { results: results[offset, limit] || [], has_more: has_more }
       if count_thread
@@ -456,8 +482,6 @@ module Mbeditor
       render json: { error: e.message }, status: :unprocessable_content
     end
 
-    MAX_REPLACE_FILES = 500
-
     # POST /mbeditor/replace_in_files
     # Replaces a string/pattern across all matching files in the workspace.
     # Returns { replaced_count:, files_affected:[], errors:[], partial: }
@@ -471,85 +495,17 @@ module Mbeditor
       return render json: { error: "Query is required" }, status: :bad_request if query.blank?
       return render json: { error: "Query too long" }, status: :bad_request if query.length > 500
 
-      # Collect all unique file paths that have at least one match.
-      # Use a large limit to get all matching files; stream_search_results handles deduplication by file internally.
-      raw_results = stream_search_results(query, 10_000, use_regex: use_regex, match_case: match_case, whole_word: whole_word)
-      file_paths = raw_results.map { |r| r[:file] }.uniq
-
-      # Fix 3: Cap the number of files to process
-      if file_paths.length > MAX_REPLACE_FILES
-        return render json: { error: "Too many files matched (#{file_paths.length}). Narrow your search." }, status: :unprocessable_entity
-      end
-
-      replaced_count = 0
-      files_affected = []
-      errors = []
-
-      # Build the Ruby Regexp to use for gsub
-      begin
-        pattern = if use_regex
-          flags = match_case ? 0 : Regexp::IGNORECASE
-          Regexp.new(whole_word ? "\\b(?:#{query})\\b" : query, flags)
-        else
-          flags = match_case ? 0 : Regexp::IGNORECASE
-          Regexp.new(whole_word ? "\\b#{Regexp.escape(query)}\\b" : Regexp.escape(query), flags)
-        end
-      rescue RegexpError => e
-        return render json: { error: "Invalid regex: #{e.message}" }, status: :bad_request
-      end
-
-      file_paths.each do |rel_path|
-        full_path = resolve_path(rel_path)
-        unless full_path
-          errors << { file: rel_path, error: "Forbidden" }
-          next
-        end
-
-        # Fix 2: Check path_blocked_for_operations?
-        if path_blocked_for_operations?(full_path)
-          errors << { file: rel_path, error: "Forbidden" }
-          next
-        end
-
-        unless File.file?(full_path)
-          errors << { file: rel_path, error: "File not found" }
-          next
-        end
-        if File.size(full_path) > MAX_OPEN_FILE_SIZE_BYTES
-          errors << { file: rel_path, error: "File too large" }
-          next
-        end
+      result = SearchReplaceService.replace(
+        workspace_root, query, replacement,
+        use_regex: use_regex, match_case: match_case, whole_word: whole_word,
+        excluded_paths: Mbeditor.configuration.excluded_paths
+      )
 
-        # Fix 1: Wrap per-file gsub/scan in a timeout to prevent ReDoS
-        begin
-          Timeout::timeout(5) do
-            content = File.binread(full_path).force_encoding("UTF-8")
-            replacements_in_file = content.scan(pattern).length
-            new_content = content.gsub(pattern, replacement)
-
-            # Fix 4: Use new_content != content instead of delta logic
-            if new_content != content
-              File.binwrite(full_path, new_content.encode("UTF-8", invalid: :replace, undef: :replace))
-              files_affected << rel_path
-              replaced_count += replacements_in_file
-            end
-          end
-        rescue Timeout::Error
-          errors << { file: rel_path, error: "Timed out processing file" }
-          next
-        rescue StandardError => e
-          errors << { file: rel_path, error: e.message }
-          next
-        end
+      if result.key?(:error)
+        render json: { error: result[:error] }, status: :unprocessable_entity
+      else
+        render json: result
       end
-
-      # Fix 5: Surface partial failure
-      render json: {
-        replaced_count: replaced_count,
-        files_affected: files_affected,
-        errors: errors,
-        partial: errors.any? && files_affected.any?
-      }
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
     end
@@ -558,7 +514,7 @@ module Mbeditor
     def git_status
       output, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "status", "--porcelain")
       branch = GitService.current_branch(workspace_root.to_s) || ""
-      files = parse_porcelain_status(output)
+      files = GitService.parse_porcelain_status(output)
       render json: { ok: status.success?, files: files, branch: branch }
     rescue StandardError => e
       render json: { error: e.message }, status: :unprocessable_content
@@ -566,120 +522,7 @@ module Mbeditor
 
     # GET /mbeditor/git_info
     def git_info
-      repo = workspace_root.to_s
-      cached = cached_git_info(repo)
-      return render json: cached if cached
-
-      branch = GitService.current_branch(repo)
-      unless branch
-        return render json: { ok: false, error: "Unable to determine current branch" }, status: :unprocessable_content
-      end
-
-      # Wave 1: all independent git reads run in parallel
-      status_t   = Thread.new { Open3.capture3("git", "-C", repo, "status", "--porcelain") }
-      numstat_t  = Thread.new { Open3.capture3("git", "-C", repo, "diff", "--numstat", "HEAD") }
-      upstream_t = Thread.new { Open3.capture3("git", "-C", repo, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}") }
-      base_t     = Thread.new { GitService.find_branch_base(repo, branch) }
-
-      working_output, _err, working_status = status_t.value
-      working_tree = working_status.success? ? parse_porcelain_status(working_output) : []
-
-      numstat_out = numstat_t.value.first
-      numstat_map = GitService.parse_numstat(numstat_out)
-      working_tree = working_tree.map { |f| f.merge(numstat_map.fetch(f[:path], {})) }
-
-      upstream_output, _err, upstream_status = upstream_t.value
-      upstream_branch = upstream_status.success? ? upstream_output.strip : nil
-      upstream_branch = nil unless upstream_branch&.match?(%r{\A[\w./-]+\z})
-
-      # Determine the branch's fork point relative to a base branch (develop/main/master).
-      # This ensures History and Changes only show work unique to this branch.
-      base_sha, base_ref = base_t.value
-
-      ahead_count    = 0
-      behind_count   = 0
-      unpushed_files = []
-      unpushed_commits = []
-      diff_base = base_sha || upstream_branch
-
-      # Wave 2: conditional parallel reads that depend on Wave 1 results
-      wave2 = {}
-      wave2[:counts]    = Thread.new { Open3.capture3("git", "-C", repo, "rev-list", "--left-right", "--count", "HEAD...#{upstream_branch}") } if upstream_branch.present?
-      wave2[:unp_log]   = Thread.new { Open3.capture3("git", "-C", repo, "log", "#{upstream_branch}..HEAD", "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e") } if upstream_branch.present?
-      wave2[:diff_name] = Thread.new { Open3.capture3("git", "-C", repo, "diff", "--name-status", "#{diff_base}..HEAD") } if diff_base.present?
-      wave2[:diff_num]  = Thread.new { Open3.capture3("git", "-C", repo, "diff", "--numstat", "#{diff_base}..HEAD") } if diff_base.present?
-      wave2[:branch_log] = Thread.new do
-        if base_sha
-          Open3.capture3("git", "-C", repo, "log", "--first-parent", "#{base_sha}..HEAD",
-                         "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
-        else
-          Open3.capture3("git", "-C", repo, "log", "--first-parent", branch, "-n", "100",
-                         "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
-        end
-      end
-
-      wave2.each_value(&:join)
-
-      if (ct = wave2[:counts])
-        counts_output, _err, counts_status = ct.value
-        if counts_status.success?
-          ahead_str, behind_str = counts_output.strip.split("\t", 2)
-          ahead_count  = ahead_str.to_i
-          behind_count = behind_str.to_i
-        end
-      end
-
-      if (ul = wave2[:unp_log])
-        unpushed_log_output, _err, unpushed_log_status = ul.value
-        unpushed_commits = GitService.parse_git_log(unpushed_log_output) if unpushed_log_status.success?
-      end
-
-      if (dn = wave2[:diff_name]) && (dnum = wave2[:diff_num])
-        diff_name_out, _err, diff_name_status = dn.value
-        if diff_name_status.success?
-          unpushed_files  = parse_name_status(diff_name_out)
-          unp_numstat_out = dnum.value.first
-          unp_numstat_map = GitService.parse_numstat(unp_numstat_out)
-          unpushed_files  = unpushed_files.map { |f| f.merge(unp_numstat_map.fetch(f[:path], {})) }
-        end
-      end
-
-      branch_log_output, _err, branch_log_status = wave2[:branch_log].value
-      branch_commits = branch_log_status.success? ? GitService.parse_git_log(branch_log_output) : []
-
-      redmine_ticket_id = nil
-      if Mbeditor.configuration.redmine_enabled
-        if Mbeditor.configuration.redmine_ticket_source == :branch
-          m = branch.match(/\A(\d+)/)
-          redmine_ticket_id = m[1] if m
-        else
-          branch_commits.each do |commit|
-            m = commit["title"]&.match(/#(\d+)/)
-            if m
-              redmine_ticket_id = m[1]
-              break
-            end
-          end
-        end
-      end
-
-      payload = {
-        ok: true,
-        branch: branch,
-        upstreamBranch: upstream_branch,
-        ahead: ahead_count,
-        behind: behind_count,
-        workingTree: working_tree,
-        unpushedFiles: unpushed_files,
-        unpushedCommits: unpushed_commits,
-        branchCommits: branch_commits,
-        branchBaseRef: base_ref,
-        redmineTicketId: redmine_ticket_id
-      }
-      store_git_info(repo, payload)
-      render json: payload
-    rescue StandardError => e
-      render json: { ok: false, error: e.message }, status: :unprocessable_content
+      render json: GitInfoService.call(workspace_root.to_s)
     end
 
     # GET /mbeditor/monaco-editor/*asset_path — serve packaged Monaco files
@@ -702,7 +545,8 @@ module Mbeditor
 
     # GET /mbeditor/manifest.webmanifest — PWA manifest
     def pwa_manifest
-      base = request.script_name.to_s.sub(%r{/$}, "")
+      raw  = root_path.chomp("/")
+      base = raw.start_with?("/") || raw.empty? ? raw : "/#{raw}"
       manifest = {
         name: "Mbeditor — #{Rails.root.basename}",
         short_name: "Mbeditor",
@@ -751,11 +595,11 @@ module Mbeditor
       path = resolve_path(params[:path])
       return render json: { error: "Forbidden" }, status: :forbidden unless path
 
-      filename = File.basename(path)
+      filename = path.to_s
       code = params[:code] || File.read(path)
 
-      if filename.end_with?('.haml')
-        unless haml_lint_available?
+      if File.basename(filename).end_with?('.haml')
+        unless AvailabilityProbe.haml_lint(workspace_root)
           return render json: { error: "haml-lint not available", markers: [] }, status: :unprocessable_content
         end
 
@@ -763,7 +607,7 @@ module Mbeditor
         return render json: { markers: markers }
       end
 
-      cmd = rubocop_command + ["--no-server", "--stdin", filename, "--format", "json", "--no-color", "--force-exclusion"]
+      cmd = AvailabilityProbe.rubocop_command(workspace_root) + ["--no-server", "--stdin", filename, "--format", "json", "--no-color"]
       env = { 'RUBOCOP_CACHE_ROOT' => File.join(Dir.tmpdir, 'rubocop') }
       output = run_with_timeout(env, cmd, stdin_data: code)
 
@@ -824,7 +668,7 @@ module Mbeditor
         f.flush
         tmpfile = f.path
 
-        cmd = rubocop_command + ["--no-server", "-A", "--no-color", tmpfile]
+        cmd = AvailabilityProbe.rubocop_command(workspace_root) + ["--no-server", "-A", "--no-color", tmpfile]
         env = { 'RUBOCOP_CACHE_ROOT' => File.join(Dir.tmpdir, 'rubocop') }
         _out, _err, status = Open3.capture3(env, *cmd)
 
@@ -867,6 +711,46 @@ module Mbeditor
       render json: { error: e.message, ok: false }, status: :unprocessable_content
     end
 
+    # GET /mbeditor/client_config — returns client-side configuration values
+    def client_config
+      render json: {
+        related_files_custom_paths: Array(Mbeditor.configuration.related_files_custom_paths)
+      }
+    end
+
+    # GET /mbeditor/related_files?path=...
+    def related_files
+      path = resolve_path(params[:path])
+      return render json: {}, status: :bad_request unless path
+      rel = relative_path(path)
+      custom = Array(Mbeditor.configuration.related_files_custom_paths)
+      result = RailsRelatedFilesService.find(workspace_root.to_s, rel, custom_paths: custom)
+      render json: result
+    end
+
+    # GET /mbeditor/changelog — serves the gem's CHANGELOG.md for the in-editor changelog tab.
+    def changelog
+      path = Mbeditor::Engine.root.join("CHANGELOG.md")
+      content = path.exist? ? path.read(encoding: "utf-8") : ""
+      render json: { content: content, version: Mbeditor::VERSION }
+    end
+
+    # GET /mbeditor/model_schema?model=User
+    # Returns the db/schema.rb table definition for the named model as JSON.
+    # 404 when the schema file is missing or the table is not found.
+    def model_schema
+      model_name = params[:model].to_s.strip
+      return render json: { error: "model required" }, status: :bad_request if model_name.blank?
+
+      schema = SchemaService.new(model_name, workspace_root.to_s).call
+      if schema
+        render json: schema
+      else
+        hint = " (Check if the model has a custom table_name or if db/schema.rb exists)"
+        render json: { error: "No schema found for '#{model_name}'#{hint}" }, status: :not_found
+      end
+    end
+
     # POST /mbeditor/format — rubocop -A on buffer content; returns corrected content WITHOUT saving to disk
     #
     # Accepts the current buffer content as `code` and formats it using a
@@ -887,7 +771,7 @@ module Mbeditor
         f.flush
         tmpfile = f.path
 
-        cmd = rubocop_command + ["--no-server", "-A", "--no-color", tmpfile]
+        cmd = AvailabilityProbe.rubocop_command(workspace_root) + ["--no-server", "-A", "--no-color", tmpfile]
         env = { 'RUBOCOP_CACHE_ROOT' => File.join(Dir.tmpdir, 'rubocop') }
         _out, _err, status = Open3.capture3(env, *cmd)
         unless status.success? || status.exitstatus == 1
@@ -903,10 +787,44 @@ module Mbeditor
 
     private
 
+    def history_file_path(branch, rel_path)
+      branch_hash = Digest::SHA256.hexdigest(branch.to_s)[0, 16]
+      file_hash   = Digest::SHA256.hexdigest(rel_path.to_s)[0, 16]
+      workspace_root.join('tmp', 'mbeditor_history', "#{branch_hash}_#{file_hash}.json")
+    end
+
+    def compact_history_ops(base, ops)
+      text = base.to_s
+      ops.each do |op|
+        sl, sc, el, ec, ins = op[0].to_i, op[1].to_i, op[2].to_i, op[3].to_i, op[4].to_s
+        lines = text.split("\n", -1)
+        sl0  = [[sl - 1, 0].max, [lines.length - 1, 0].max].min
+        el0  = [[el - 1, 0].max, [lines.length - 1, 0].max].min
+        sc0  = sc - 1
+        ec0  = ec - 1
+        prefix    = (lines[sl0] || '')[0, sc0] || ''
+        suffix    = (lines[el0] || '')[ec0..] || ''
+        ins_lines = ins.split("\n", -1)
+        new_seg   = if ins_lines.length <= 1
+          [prefix + (ins_lines[0] || '') + suffix]
+        else
+          [prefix + ins_lines[0]] + ins_lines[1..-2] + [ins_lines[-1] + suffix]
+        end
+        text = (lines[0...sl0] + new_seg + lines[(el0 + 1)..]).join("\n")
+      end
+      text
+    rescue StandardError
+      base.to_s
+    end
+
     def broadcast_files_changed
       root = workspace_root.to_s
-      invalidate_file_tree_cache(root)
-      invalidate_git_info_cache(root)
+      FileTreeService.invalidate(root)
+      Thread.new do
+        GitInfoService.invalidate(root)
+      rescue => e
+        Rails.logger.warn("[mbeditor] GitInfoService.invalidate failed: #{e}")
+      end
 
       return unless defined?(ActionCable.server)
 
@@ -915,11 +833,15 @@ module Mbeditor
       # Never let a broadcast failure affect the HTTP response
     end
 
+    def editor_state_service
+      @editor_state_service ||= EditorStateService.new(workspace_root)
+    end
+
     def sanitize_branch_name(branch)
       return nil if branch.blank?
       str = branch.to_s.strip
       return nil if str.include?('..')
-      str.match?(SAFE_BRANCH_NAME) ? str : nil
+      str.match?(EditorStateService::SAFE_BRANCH_NAME) ? str : nil
     end
 
     def action_cable_enabled?
@@ -961,173 +883,18 @@ module Mbeditor
       rel = relative_path(full_path)
       return true if rel.blank?
 
-      excluded_path?(rel, File.basename(full_path))
-    end
-
-    # Stream search results using popen so we can stop reading early once we
-    # have collected `limit` matches (avoids buffering the entire rg/grep output
-    # in memory when searching large codebases for common tokens).
-    def stream_search_results(query, limit, use_regex: false, match_case: false, whole_word: false)
-      results = []
-
-      if RG_AVAILABLE
-        args = ["rg", "--json", "--no-ignore"]
-        args << "-F" unless use_regex
-        args << "--ignore-case" unless match_case
-        args << "--word-regexp" if whole_word
-        excluded_paths.each { |p| args << "--glob=!#{p}" }
-        args += ["--", query, workspace_root.to_s]
-
-        IO.popen(args, err: File::NULL) do |io|
-          io.each_line do |raw|
-            break if results.length >= limit
-
-            begin
-              data = JSON.parse(raw)
-            rescue JSON::ParserError => e
-              Rails.logger.warn("[mbeditor] search: malformed rg JSON line: #{e.message}")
-              next
-            end
-            next unless data["type"] == "match"
-
-            md = data["data"]
-            results << {
-              file: relative_path(md.dig("path", "text").to_s),
-              line: md.dig("line_number"),
-              text: md.dig("lines", "text").to_s.strip
-            }
-          end
-        end
-      else
-        base_flags = use_regex ? "-E" : "-F"
-        args = ["grep", "-rn", base_flags]
-        args << "-i" unless match_case
-        args << "-w" if whole_word
-        excluded_dirnames.select { |d| d.match?(/\A[\w.\/-]+\z/) }.each { |d| args << "--exclude-dir=#{d}" }
-        args += [query, workspace_root.to_s]
-
-        IO.popen(args, err: File::NULL) do |io|
-          io.each_line do |raw|
-            break if results.length >= limit
-
-            raw.chomp!
-            next unless raw =~ /\A(.+?):(\d+):(.*)\z/
-
-            file_path = Regexp.last_match(1)
-            next unless file_path.start_with?(workspace_root.to_s)
-
-            rel = relative_path(file_path)
-            next if excluded_path?(rel, File.basename(file_path))
-
-            results << {
-              file: rel,
-              line: Regexp.last_match(2).to_i,
-              text: Regexp.last_match(3).strip
-            }
-          end
-        end
-      end
-
-      results
-    end
-
-    # Count total matching lines across the workspace using rg --count (or grep -c).
-    # Fast: rg just counts without extracting context. Runs in a background thread.
-    def count_search_results(query, use_regex: false, match_case: false, whole_word: false)
-      total = 0
-      if RG_AVAILABLE
-        args = ["rg", "--count", "--no-ignore"]
-        args << "-F" unless use_regex
-        args << "--ignore-case" unless match_case
-        args << "--word-regexp" if whole_word
-        excluded_paths.each { |p| args << "--glob=!#{p}" }
-        args += ["--", query, workspace_root.to_s]
-        IO.popen(args, err: File::NULL) do |io|
-          io.each_line { |line| total += line.strip.split(":").last.to_i rescue 0 }
-        end
-      else
-        base_flags = use_regex ? "-E" : "-F"
-        args = ["grep", "-rc", base_flags]
-        args << "-i" unless match_case
-        args << "-w" if whole_word
-        excluded_dirnames.each { |d| args << "--exclude-dir=#{d}" }
-        args += [query, workspace_root.to_s]
-        IO.popen(args, err: File::NULL) do |io|
-          io.each_line { |line| total += line.strip.split(":").last.to_i rescue 0 }
-        end
-      end
-      total
-    rescue StandardError
-      0
-    end
-
-    def build_tree(dir, max_depth: 10, depth: 0)
-      return [] if depth >= max_depth
-
-      entries = Dir.entries(dir).sort.reject { |entry| entry == "." || entry == ".." }
-      entries.filter_map do |name|
-        full = File.join(dir, name)
-        rel = relative_path(full)
-
-        if File.directory?(full)
-          { name: name, type: "folder", path: rel, children: build_tree(full, depth: depth + 1) }
-        else
-          size = File.size(full) rescue nil
-          { name: name, type: "file", path: rel, size: size }
-        end
-      end
-    rescue Errno::EACCES
-      []
-    end
-
-    def excluded_paths
-      Array(Mbeditor.configuration.excluded_paths).map(&:to_s).reject(&:blank?)
-    end
-
-    def excluded_dirnames
-      excluded_paths.filter { |path| !path.include?("/") }
+      ExclusionMatcher.new(Mbeditor.configuration.excluded_paths).excluded?(rel)
     end
 
     def ruby_def_include_dirs
       Array(Mbeditor.configuration.ruby_def_include_dirs).map(&:to_s).reject(&:blank?)
     end
 
-    def excluded_path?(relative_path, name)
-      excluded_paths.any? do |pattern|
-        if pattern.include?("/")
-          relative_path == pattern || relative_path.start_with?("#{pattern}/")
-        else
-          name == pattern || relative_path.split("/").include?(pattern)
-        end
-      end
-    end
-
     def run_with_timeout(env, cmd, stdin_data:)
       timeout_seconds = Mbeditor.configuration.lint_timeout&.to_i
-      output = +""; timed_out = false
-
-      Open3.popen3(env, *cmd, pgroup: true) do |stdin, stdout, _stderr, wait_thr|
-        stdin.write(stdin_data)
-        stdin.close
-
-        timer = if timeout_seconds && timeout_seconds > 0
-          Thread.new do
-            sleep timeout_seconds
-            timed_out = true
-            Process.kill('-KILL', wait_thr.pid)
-          rescue Errno::ESRCH
-            nil
-          end
-        end
-
-        output = stdout.read
-        wait_thr.value
-        timer&.kill
-      end
-
-      raise "RuboCop timed out after #{timeout_seconds} seconds" if timed_out
-
-      output
+      timeout = timeout_seconds && timeout_seconds > 0 ? timeout_seconds : nil
+      result = ProcessRunner.call(cmd, timeout: timeout, env: env, stdin_data: stdin_data)
+      result[:stdout]
     end
 
     def cop_severity(severity)
@@ -1182,143 +949,22 @@ module Mbeditor
       }
     end
 
-    def rubocop_command
-      command = Mbeditor.configuration.rubocop_command.to_s.strip
-      command = "rubocop" if command.empty?
-      tokens = Shellwords.split(command)
-
-      local_bin = workspace_root.join("bin", "rubocop")
-      return [local_bin.to_s] if tokens == ["rubocop"] && local_bin.exist?
-
-      tokens
-    rescue ArgumentError
-      ["rubocop"]
-    end
-
     def rubocop_config_path
       candidate = workspace_root.join(".rubocop.yml")
       candidate.exist? ? ".rubocop.yml" : nil
     end
 
-    PROBE_MUTEX     = Mutex.new
-    GIT_INFO_MUTEX  = Mutex.new
-    FILE_TREE_MUTEX = Mutex.new
-    private_constant :PROBE_MUTEX, :GIT_INFO_MUTEX, :FILE_TREE_MUTEX
-
-    def rubocop_available?
-      key = Mbeditor.configuration.rubocop_command.to_s
-      probe_cached(:@rubocop_available_cache, key) do
-        _out, _err, status = Open3.capture3(*rubocop_command, "--version")
-        status.success?
-      end
-    end
-
-    def haml_lint_available?
-      cmd = haml_lint_command
-      key = cmd.join(" ")
-      probe_cached(:@haml_lint_available_cache, key) do
-        _out, _err, status = Open3.capture3(*cmd, "--version")
-        status.success?
-      end
-    end
-
-    def git_available?
-      key = workspace_root.to_s
-      probe_cached(:@git_available_cache, key) do
-        _out, _err, status = Open3.capture3("git", "-C", key, "rev-parse", "--is-inside-work-tree")
-        status.success?
-      end
-    end
-
-    def cached_git_info(repo, ttl: 5)
-      GIT_INFO_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(:@git_info_cache) || {}
-        entry = cache[repo]
-        return entry[:data] if entry && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - entry[:ts]) < ttl
-      end
-      nil
-    end
-
-    def store_git_info(repo, data)
-      GIT_INFO_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(:@git_info_cache) || {}
-        cache[repo] = { ts: Process.clock_gettime(Process::CLOCK_MONOTONIC), data: data }
-        self.class.instance_variable_set(:@git_info_cache, cache)
-      end
-    end
-
-    def invalidate_git_info_cache(repo)
-      GIT_INFO_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(:@git_info_cache) || {}
-        cache.delete(repo)
-        self.class.instance_variable_set(:@git_info_cache, cache)
-      end
-    end
-
-    def cached_file_tree(root, ttl: 15)
-      FILE_TREE_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(:@file_tree_cache) || {}
-        entry = cache[root]
-        return entry[:data] if entry && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - entry[:ts]) < ttl
-      end
-      nil
-    end
-
-    def store_file_tree(root, data)
-      FILE_TREE_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(:@file_tree_cache) || {}
-        cache[root] = { ts: Process.clock_gettime(Process::CLOCK_MONOTONIC), data: data }
-        self.class.instance_variable_set(:@file_tree_cache, cache)
-      end
-    end
-
-    def invalidate_file_tree_cache(root)
-      FILE_TREE_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(:@file_tree_cache) || {}
-        cache.delete(root)
-        self.class.instance_variable_set(:@file_tree_cache, cache)
-      end
-    end
-
-    def probe_cached(ivar, key, &block)
-      PROBE_MUTEX.synchronize do
-        cache = self.class.instance_variable_get(ivar) ||
-                self.class.instance_variable_set(ivar, {})
-        unless cache.key?(key)
-          cache[key] = begin
-            block.call
-          rescue StandardError
-            false
-          end
-        end
-        cache[key]
-      end
-    end
-
-    alias git_blame_available? git_available?
-
     def test_available?
       root = workspace_root.to_s
       File.directory?(File.join(root, "test")) || File.directory?(File.join(root, "spec"))
     end
 
-    def haml_lint_command
-      workspace_bin = workspace_root.join("bin", "haml-lint")
-      return [workspace_bin.to_s] if workspace_bin.exist?
-
-      begin
-        [Gem.bin_path("haml_lint", "haml-lint")]
-      rescue Gem::Exception, Gem::GemNotFoundException
-        ["haml-lint"]
-      end
-    end
-
     def run_haml_lint(code)
       markers = []
       Tempfile.create(["mbeditor_haml", ".haml"]) do |f|
         f.write(code)
         f.flush
-        output, _err, _status = Open3.capture3(*haml_lint_command, "--reporter", "json", "--no-color", f.path)
+        output, _err, _status = Open3.capture3(*AvailabilityProbe.haml_lint_command(workspace_root), "--reporter", "json", "--no-color", f.path)
         idx = output.index("{")
         result = idx ? JSON.parse(output[idx..]) : {}
         result = {} unless result.is_a?(Hash)
@@ -1345,30 +991,6 @@ module Mbeditor
       end
     end
 
-    def parse_porcelain_status(output)
-      output.lines.filter_map do |line|
-        next if line.length < 4
-
-        path = line[3..].to_s.strip
-        next if path.blank?
-
-        { status: line[0..1].strip, path: path }
-      end
-    end
-
-    def parse_name_status(output)
-      output.lines.filter_map do |line|
-        parts = line.strip.split("\t")
-        next if parts.empty?
-
-        status = parts[0].to_s.strip
-        path = parts.last.to_s.strip
-        next if path.blank?
-
-        { status: status, path: path }
-      end
-    end
-
     def monaco_worker_file
       engine_path = Mbeditor::Engine.root.join("public", "monaco_worker.js")
       return engine_path if engine_path.file?
@@ -1399,7 +1021,7 @@ module Mbeditor
 
     def render_file_too_large(size)
       render json: {
-        error: "File is too large to open (#{human_size(size)}). Limit is #{human_size(MAX_OPEN_FILE_SIZE_BYTES)}."
+        error: "File is too large to open (#{human_size(size)}). Limit is #{human_size(FileOperationService::MAX_FILE_SIZE_BYTES)}."
       }, status: :content_too_large
     end