mbeditor 0.2.2

data/app/controllers/mbeditor/git_controller.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Thin controller for all Git-related endpoints added in the Git & Code Review
+  # system.  All heavy logic lives in service objects under app/services/mbeditor/.
+  #
+  # Endpoints
+  # ---------
+  # GET  /mbeditor/git/diff          ?file=<path>[&base=<sha>&head=<sha>]
+  # GET  /mbeditor/git/blame         ?file=<path>
+  # GET  /mbeditor/git/file_history  ?file=<path>
+  # GET  /mbeditor/git/commit_graph
+  # GET  /mbeditor/redmine/issue/:id
+  class GitController < ApplicationController
+    skip_before_action :verify_authenticity_token
+    before_action :ensure_allowed_environment!
+
+    # GET /mbeditor/git/diff?file=<path>[&base=<sha>&head=<sha>]
+    def diff
+      file = require_file_param
+      return unless file
+
+      base = params[:base].presence
+      head = params[:head].presence
+      # 'WORKING' is a frontend sentinel meaning current on-disk working tree
+      head = nil if head == 'WORKING'
+      # Allow full/short SHA hashes plus common git ref formats: branch names,
+      # HEAD, remote tracking refs, parent notation (sha^, sha~N) and tags.
+      valid_ref = /\A[a-zA-Z0-9._\-\/\^~@]+\z/
+      if [base, head].any? { |s| s && (s.length > 200 || !s.match?(valid_ref)) }
+        return render json: { error: 'Invalid ref' }, status: :bad_request
+      end
+
+      result = GitDiffService.new(
+        repo_path: workspace_root,
+        file_path: file,
+        base_sha: base,
+        head_sha: head
+      ).call
+
+      render json: result
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/git/blame?file=<path>
+    def blame
+      file = require_file_param
+      return unless file
+
+      lines = GitBlameService.new(repo_path: workspace_root, file_path: file).call
+      render json: { lines: lines }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/git/file_history?file=<path>
+    def file_history
+      file = require_file_param
+      return unless file
+
+      commits = GitFileHistoryService.new(repo_path: workspace_root, file_path: file).call
+      render json: { commits: commits }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/git/commit_graph
+    def commit_graph
+      commits = GitCommitGraphService.new(repo_path: workspace_root).call
+      render json: { commits: commits }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/git/commit_detail?sha=<hash>
+    def commit_detail
+      sha = params[:sha].to_s.strip
+      return render json: { error: "sha required" }, status: :bad_request if sha.blank?
+      return render json: { error: "Invalid sha" }, status: :bad_request unless sha.match?(/\A[0-9a-fA-F]{1,40}\z/)
+
+      files_output, _err, files_status = Open3.capture3(
+        "git", "-C", workspace_root.to_s,
+        "diff-tree", "--no-commit-id", "-r", "--name-status", sha
+      )
+      numstat_output, _err, numstat_status = Open3.capture3(
+        "git", "-C", workspace_root.to_s,
+        "diff-tree", "--no-commit-id", "-r", "--numstat", sha
+      )
+
+      numstat_map = {}
+      if numstat_status.success?
+        numstat_output.lines.each do |line|
+          parts = line.strip.split("\t", 3)
+          next if parts.length < 3 || parts[0] == "-"
+
+          numstat_map[parts[2].strip] = { "added" => parts[0].to_i, "removed" => parts[1].to_i }
+        end
+      end
+
+      files = []
+      if files_status.success?
+        files = files_output.lines.map do |line|
+          parts = line.strip.split("\t", 2)
+          next if parts.length < 2
+          file = { "status" => parts[0].strip, "path" => parts[1].strip }
+          file.merge(numstat_map.fetch(file["path"], {}))
+        end.compact
+      end
+
+      log_output, _err, log_status = Open3.capture3(
+        "git", "-C", workspace_root.to_s,
+        "log", "-1", "--pretty=format:%s%x1f%an%x1f%aI", sha
+      )
+      meta = {}
+      if log_status.success?
+        fields = log_output.strip.split("\x1f", 3)
+        meta = { "title" => fields[0].to_s, "author" => fields[1].to_s, "date" => fields[2].to_s }
+      end
+
+      render json: { sha: sha, title: meta["title"] || "", author: meta["author"] || "", date: meta["date"] || "", files: files }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/git/combined_diff?scope=local|branch
+    # Returns the raw unified diff text for all files in the given scope.
+    # scope=local  → git diff HEAD  (working tree vs HEAD)
+    # scope=branch → git diff <branch-base>..HEAD (same baseline as git_info)
+    def combined_diff
+      scope = params[:scope] == 'branch' ? :branch : :local
+
+      if scope == :local
+        out, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "diff", "HEAD")
+        out = status.success? ? out : ""
+      else
+        repo = workspace_root.to_s
+        branch = GitService.current_branch(repo)
+        base_sha, = find_branch_base(repo, branch)
+
+        if base_sha.present?
+          out, _err, status = Open3.capture3("git", "-C", repo, "diff", "#{base_sha}..HEAD")
+          out = status.success? ? out : ""
+        else
+          upstream_out, _err, upstream_status = Open3.capture3(
+            "git", "-C", repo,
+            "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"
+          )
+          upstream = upstream_status.success? ? upstream_out.strip : nil
+          upstream = nil unless upstream&.match?(%r{\A[\w./-]+\z})
+
+          if upstream.present?
+            out, _err, status = Open3.capture3("git", "-C", repo, "diff", "#{upstream}..HEAD")
+            out = status.success? ? out : ""
+          else
+            out = ""
+          end
+        end
+      end
+
+      render plain: out, content_type: "text/plain"
+    rescue StandardError
+      render plain: "", content_type: "text/plain"
+    end
+
+    # GET /mbeditor/redmine/issue/:id
+    def redmine_issue
+      unless Mbeditor.configuration.redmine_enabled
+        return render json: { error: 'Redmine integration is disabled.' }, status: :service_unavailable
+      end
+
+      return render json: { error: 'Invalid issue id' }, status: :bad_request unless params[:id].to_s.match?(/\A\d+\z/)
+
+      result = RedmineService.new(issue_id: params[:id]).call
+      render json: result
+    rescue RedmineDisabledError => e
+      render json: { error: e.message }, status: :service_unavailable
+    rescue RedmineConfigError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    private
+
+    # Require & validate a `file` query param, responding 400/403 on bad input.
+    # Returns the relative path string on success, or nil if already responded.
+    def require_file_param
+      raw = params[:file].to_s.strip
+
+      if raw.blank?
+        render json: { error: "file parameter is required" }, status: :bad_request
+        return nil
+      end
+
+      full = resolve_path(raw)
+      unless full
+        render json: { error: "Forbidden" }, status: :forbidden
+        return nil
+      end
+
+      relative_path(full)
+    end
+
+    # Returns [merge_base_sha, ref_name] of the first candidate base branch found,
+    # or [nil, nil] if none can be determined.
+    def find_branch_base(repo, current_branch)
+      candidates = %w[origin/develop origin/main origin/master develop main master]
+      head_sha_out, = Open3.capture3("git", "-C", repo, "rev-parse", "HEAD")
+      head_sha = head_sha_out.strip
+
+      candidates.each do |ref|
+        short = ref.delete_prefix("origin/")
+        next if short == current_branch || ref == current_branch
+
+        _o, _e, st = Open3.capture3("git", "-C", repo, "rev-parse", "--verify", "--quiet", ref)
+        next unless st.success?
+
+        base_out, _e, base_st = Open3.capture3("git", "-C", repo, "merge-base", "HEAD", ref)
+        next unless base_st.success?
+
+        sha = base_out.strip
+        next unless sha.match?(/\A[0-9a-f]{40}\z/)
+        next if sha == head_sha
+
+        return [sha, ref]
+      end
+
+      [nil, nil]
+    rescue StandardError
+      [nil, nil]
+    end
+  end
+end

data/app/services/mbeditor/git_blame_service.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Mbeditor
+  # Wraps `git blame --porcelain` and returns structured per-line blame data.
+  #
+  # Each result entry:
+  #   {
+  #     "line"    => Integer,   # 1-indexed line number
+  #     "sha"     => String,    # full 40-char commit sha
+  #     "author"  => String,
+  #     "email"   => String,
+  #     "date"    => String,    # ISO-8601
+  #     "summary" => String,    # commit subject line
+  #     "content" => String     # raw source line (without trailing newline)
+  #   }
+  class GitBlameService
+    include GitService
+
+    attr_reader :repo_path, :file_path
+
+    def initialize(repo_path:, file_path:)
+      @repo_path = repo_path.to_s
+      @file_path = file_path.to_s
+    end
+
+    # Returns Array of line blame hashes, or raises RuntimeError.
+    def call
+      output, status = GitService.run_git(repo_path, "blame", "--porcelain", "--", file_path)
+      raise "git blame failed for #{file_path}" unless status.success?
+
+      parse_porcelain(output)
+    end
+
+    private
+
+    def parse_porcelain(output)
+      results   = []
+      commits   = {}  # sha -> metadata cache (porcelain repeats sha for first occurrence only)
+      current   = {}
+
+      output.each_line do |raw|
+        line = raw.chomp
+
+        # Header line: "<sha> <orig-line> <result-line> [<num-lines>]"
+        if line =~ /\A([0-9a-f]{40}) \d+ (\d+)/
+          sha        = Regexp.last_match(1)
+          result_num = Regexp.last_match(2).to_i
+          commits[sha] ||= {}
+          current = { "sha" => sha, "line" => result_num }.merge(commits[sha])
+          next
+        end
+
+        # Content line (starts with TAB)
+        if line.start_with?("\t")
+          current["content"] = line[1..-1] # strip leading tab
+          commits[current["sha"]] = current.slice("author", "email", "date", "summary") if current["author"]
+          results << current.dup
+          current = {}
+          next
+        end
+
+        # Metadata lines
+        case line
+        when /\Aauthor (.+)/
+          current["author"] = Regexp.last_match(1)
+          commits[current["sha"]] ||= {}
+          commits[current["sha"]]["author"] = current["author"]
+        when /\Aauthor-mail <(.+)>/
+          current["email"] = Regexp.last_match(1)
+          commits[current["sha"]] ||= {}
+          commits[current["sha"]]["email"] = current["email"]
+        when /\Aauthor-time (\d+)/
+          ts = Regexp.last_match(1).to_i
+          current["date"] = Time.at(ts).utc.iso8601
+          commits[current["sha"]] ||= {}
+          commits[current["sha"]]["date"] = current["date"]
+        when /\Asummary (.+)/
+          current["summary"] = Regexp.last_match(1)
+          commits[current["sha"]] ||= {}
+          commits[current["sha"]]["summary"] = current["summary"]
+        end
+
+        # Merge cached metadata for repeat shas so every entry is complete
+        if current["sha"] && commits[current["sha"]]
+          cached = commits[current["sha"]]
+          current["author"]  ||= cached["author"]
+          current["email"]   ||= cached["email"]
+          current["date"]    ||= cached["date"]
+          current["summary"] ||= cached["summary"]
+        end
+      end
+
+      results
+    end
+  end
+end

data/app/services/mbeditor/git_commit_graph_service.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Builds commit graph data for rendering a VSCode-style commit graph.
+  #
+  # Each commit entry:
+  #   {
+  #     "hash"     => String,          # full 40-char sha
+  #     "parents"  => Array<String>,   # parent sha(s) — enables line drawing
+  #     "title"    => String,
+  #     "author"   => String,
+  #     "date"     => String,          # ISO-8601
+  #     "isLocal"  => Boolean          # true if commit is ahead of upstream
+  #   }
+  class GitCommitGraphService
+    include GitService
+
+    MAX_COMMITS = 150
+
+    attr_reader :repo_path
+
+    def initialize(repo_path:)
+      @repo_path = repo_path.to_s
+    end
+
+    def call
+      output, status = GitService.run_git(
+        repo_path,
+        "log",
+        "--all",
+        "-n", MAX_COMMITS.to_s,
+        "--pretty=format:%H%x1f%P%x1f%s%x1f%an%x1f%aI%x1e"
+      )
+
+      raise "git log failed" unless status.success?
+
+      commits = GitService.parse_git_log_with_parents(output)
+      local_shas = local_commit_shas
+
+      commits.map do |c|
+        c.merge("isLocal" => local_shas.include?(c["hash"]))
+      end
+    end
+
+    private
+
+    # Returns a Set of commit shas that are ahead of the upstream (i.e. not yet pushed).
+    def local_commit_shas
+      upstream = GitService.upstream_branch(repo_path)
+      return Set.new if upstream.blank?
+
+      out, status = GitService.run_git(repo_path, "rev-list", "HEAD...#{upstream}", "--left-only")
+      return Set.new unless status.success?
+
+      Set.new(out.lines.map(&:strip).reject(&:blank?))
+    rescue StandardError
+      Set.new
+    end
+  end
+end

data/app/services/mbeditor/git_diff_service.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Produces original/modified content pairs suitable for Monaco's diff editor.
+  #
+  # Modes
+  # -----
+  # 1. Working tree vs HEAD (default when no sha given)
+  #    original = HEAD version of the file
+  #    modified = current on-disk content
+  #
+  # 2. Specific commit vs its parent
+  #    original = file at <base_sha>
+  #    modified = file at <head_sha>
+  class GitDiffService
+    include GitService
+
+    attr_reader :repo_path, :file_path, :base_sha, :head_sha
+
+    def initialize(repo_path:, file_path:, base_sha: nil, head_sha: nil)
+      @repo_path = repo_path.to_s
+      @file_path = file_path.to_s
+      @base_sha  = base_sha.presence
+      @head_sha  = head_sha.presence
+    end
+
+    # Returns { original: String, modified: String } or raises RuntimeError.
+    def call
+      if base_sha && head_sha
+        diff_between_commits
+      elsif base_sha
+        # base_sha provided but head_sha is nil: diff that ref vs the working tree
+        { "original" => file_at_ref(base_sha, file_path), "modified" => on_disk_content }
+      else
+        diff_working_tree_vs_head
+      end
+    end
+
+    private
+
+    def diff_working_tree_vs_head
+      original = file_at_ref("HEAD", file_path)
+      modified = on_disk_content
+
+      { "original" => original, "modified" => modified }
+    end
+
+    def diff_between_commits
+      original = file_at_ref(base_sha, file_path)
+      modified = file_at_ref(head_sha, file_path)
+
+      { "original" => original, "modified" => modified }
+    end
+
+    # Return the file content at a given git ref, or "" if it doesn't exist.
+    def file_at_ref(ref, path)
+      out, status = GitService.run_git(repo_path, "show", "#{ref}:#{path}")
+      return "" unless status.success?
+
+      out
+    rescue StandardError
+      ""
+    end
+
+    def on_disk_content
+      full = GitService.resolve_path(repo_path, file_path)
+      return "" unless full && File.file?(full)
+
+      File.read(full, encoding: "UTF-8", invalid: :replace, undef: :replace)
+    rescue StandardError
+      ""
+    end
+  end
+end

data/app/services/mbeditor/git_file_history_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Returns the per-file commit history using `git log --follow`.
+  #
+  # Each entry:
+  #   {
+  #     "hash"   => String,
+  #     "title"  => String,
+  #     "author" => String,
+  #     "date"   => String   # ISO-8601
+  #   }
+  class GitFileHistoryService
+    include GitService
+
+    MAX_COMMITS = 200
+
+    attr_reader :repo_path, :file_path
+
+    def initialize(repo_path:, file_path:)
+      @repo_path = repo_path.to_s
+      @file_path = file_path.to_s
+    end
+
+    # Returns Array of commit hashes for the file.
+    def call
+      output, status = GitService.run_git(
+        repo_path,
+        "log",
+        "--follow",
+        "-n", MAX_COMMITS.to_s,
+        "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e",
+        "--",
+        file_path
+      )
+
+      raise "git log failed for #{file_path}" unless status.success?
+
+      GitService.parse_git_log(output)
+    end
+  end
+end

data/app/services/mbeditor/git_service.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Mbeditor
+  # Shared helpers for running git CLI commands read-only inside a repo.
+  # All public methods accept +repo_path+ as their first argument so services
+  # stay stateless and composable.
+  module GitService
+    module_function
+
+    # Safe pattern for git ref names (branch, remote/branch, tag).
+    # Rejects refs containing whitespace, NUL, shell metacharacters, or
+    # git reflog syntax (e.g. "@{" sequences beyond the trailing "@{u}").
+    SAFE_GIT_REF = %r{\A[\w./-]+\z}
+
+    # Run an arbitrary git command inside +repo_path+.
+    # Returns [stdout, Process::Status]. stderr is captured and discarded to
+    # prevent git diagnostic messages from leaking into the Rails server log.
+    def run_git(repo_path, *args)
+      out, _err, status = Open3.capture3("git", "-C", repo_path, *args)
+      [out, status]
+    end
+
+    # Current branch name, or nil if not in a git repo.
+    # Uses rev-parse for compatibility with Git < 2.22 (which lacks --show-current).
+    def current_branch(repo_path)
+      out, status = run_git(repo_path, "rev-parse", "--abbrev-ref", "HEAD")
+      status.success? ? out.strip : nil
+    end
+
+    # Upstream tracking branch for the current branch, e.g. "origin/main".
+    # Returns nil if the branch name contains characters outside SAFE_GIT_REF.
+    def upstream_branch(repo_path)
+      out, status = run_git(repo_path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
+      return nil unless status.success?
+
+      ref = out.strip
+      ref.match?(SAFE_GIT_REF) ? ref : nil
+    end
+
+    # Returns [ahead_count, behind_count] relative to upstream, or [0,0].
+    def ahead_behind(repo_path, upstream)
+      return [0, 0] if upstream.blank?
+      return [0, 0] unless upstream.match?(SAFE_GIT_REF)
+
+      out, status = run_git(repo_path, "rev-list", "--left-right", "--count", "HEAD...#{upstream}")
+      return [0, 0] unless status.success?
+
+      parts = out.strip.split("\t", 2)
+      [parts[0].to_i, parts[1].to_i]
+    end
+
+    # Parse compact `git log --pretty=format:%H%x1f%P%x1f%s%x1f%an%x1f%aI%x1e` output.
+    # Returns Array of hashes.
+    def self.parse_git_log_with_parents(raw_output)
+      raw_output.split("\x1e").map do |entry|
+        fields = entry.strip.split("\x1f", 5)
+        next unless fields.length == 5
+
+        {
+          "hash"    => fields[0],
+          "parents" => fields[1].split.reject(&:blank?),
+          "title"   => fields[2],
+          "author"  => fields[3],
+          "date"    => fields[4]
+        }
+      end.compact
+    end
+
+    # Parse compact `git log --pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e` output.
+    def self.parse_git_log(raw_output)
+      raw_output.split("\x1e").map do |entry|
+        fields = entry.strip.split("\x1f", 4)
+        next unless fields.length == 4
+
+        {
+          "hash"   => fields[0],
+          "title"  => fields[1],
+          "author" => fields[2],
+          "date"   => fields[3]
+        }
+      end.compact
+    end
+
+    # Resolve a file path safely within repo_path.  Returns full path string or
+    # nil if the path escapes the root.
+    def resolve_path(repo_path, relative)
+      return nil if relative.blank?
+
+      full = File.expand_path(relative.to_s, repo_path.to_s)
+      full.start_with?(repo_path.to_s + "/") || full == repo_path.to_s ? full : nil
+    end
+  end
+end

data/app/services/mbeditor/redmine_service.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Mbeditor
+  class RedmineDisabledError < StandardError
+    def initialize
+      super("Redmine integration is not enabled. Set config.mbeditor.redmine_enabled = true.")
+    end
+  end
+
+  class RedmineConfigError < StandardError; end
+
+  # Fetches a Redmine issue via the REST API.
+  #
+  # Only usable when Mbeditor.configuration.redmine_enabled is true.
+  #
+  # Returns:
+  #   {
+  #     "id"          => Integer,
+  #     "title"       => String,
+  #     "description" => String,
+  #     "status"      => String,
+  #     "author"      => String,
+  #     "notes"       => Array<String>
+  #   }
+  class RedmineService
+    TIMEOUT_SECONDS = 5
+
+    attr_reader :issue_id
+
+    def initialize(issue_id:)
+      @issue_id = issue_id.to_s
+    end
+
+    def call
+      raise RedmineDisabledError unless Mbeditor.configuration.redmine_enabled
+
+      config = Mbeditor.configuration
+      raise RedmineConfigError, "redmine_url is not configured" if config.redmine_url.blank?
+      raise RedmineConfigError, "redmine_api_key is not configured" if config.redmine_api_key.blank?
+
+      fetch_issue(config.redmine_url, config.redmine_api_key)
+    end
+
+    private
+
+    def fetch_issue(base_url, api_key)
+      uri = URI.parse("#{base_url.chomp('/')}/issues/#{issue_id}.json")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = TIMEOUT_SECONDS
+      http.read_timeout = TIMEOUT_SECONDS
+
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request["X-Redmine-API-Key"] = api_key
+      request["Accept"] = "application/json"
+
+      response = http.request(request)
+
+      raise "Redmine returned HTTP #{response.code} for issue ##{issue_id}" unless response.is_a?(Net::HTTPSuccess)
+
+      data = JSON.parse(response.body)
+      issue = data["issue"] || {}
+
+      {
+        "id"          => issue["id"],
+        "title"       => issue.dig("subject"),
+        "description" => issue.dig("description").to_s,
+        "status"      => issue.dig("status", "name"),
+        "author"      => issue.dig("author", "name"),
+        "notes"       => extract_notes(issue)
+      }
+    end
+
+    def extract_notes(issue)
+      journals = issue["journals"] || []
+      journals
+        .select { |j| j["notes"].to_s.present? }
+        .map { |j| { "author" => j.dig("user", "name"), "note" => j["notes"], "date" => j["created_on"] } }
+    end
+  end
+end