mbeditor 0.1.6 → 0.1.7

data/app/assets/stylesheets/mbeditor/application.css

@@ -2,6 +2,37 @@
  *= require mbeditor/editor
  */
 
+/* ── Theme-aware CSS variables ───────────────────────────────────────── */
+:root,
+[data-theme="vs-dark"] {
+  --panel-bg: #1e1e1e;
+  --header-bg: #252526;
+  --border-color: #3c3c3c;
+  --text-primary: #d4d4d4;
+  --status-hover-bg: rgba(255,255,255,0.08);
+}
+[data-theme="vs"] {
+  --panel-bg: #f3f3f3;
+  --header-bg: #e8e8e8;
+  --border-color: #c8c8c8;
+  --text-primary: #1e1e1e;
+  --status-hover-bg: rgba(0,0,0,0.06);
+}
+[data-theme="hc-black"] {
+  --panel-bg: #000000;
+  --header-bg: #0a0a0a;
+  --border-color: #6fc3df;
+  --text-primary: #ffffff;
+  --status-hover-bg: rgba(255,255,255,0.12);
+}
+[data-theme="hc-light"] {
+  --panel-bg: #ffffff;
+  --header-bg: #f8f8f8;
+  --border-color: #0f4a85;
+  --text-primary: #000000;
+  --status-hover-bg: rgba(0,0,0,0.06);
+}
+
 /* ── Git & Code Review Styles ───────────────────────────────────────── */
 
 /* Status Bar Git Sync */
@@ -369,23 +400,78 @@
   gap: 4px;
 }
 
+/* Shared modal backdrop + panel */
+.ide-modal-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 9000;
+  background: rgba(0,0,0,0.55);
+}
+.ide-modal-panel {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 9001;
+  width: 560px;
+  max-width: 90vw;
+  max-height: 75vh;
+  background-color: var(--panel-bg);
+  border: 1px solid var(--border-color);
+  box-shadow: 0 8px 32px rgba(0,0,0,0.6);
+  border-radius: 6px;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
 /* File History Panel */
 .ide-file-history {
-  position: absolute;
-  top: 40px;
-  right: 20px;
-  width: 400px;
-  max-width: calc(100% - 40px);
-  max-height: calc(100% - 80px);
-  background-color: var(--panel-bg);
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  width: 480px;
+  max-width: calc(100vw - 40px);
+  max-height: 70vh;
+  background: #1e1f22;
   border: 1px solid var(--border-color);
-  box-shadow: 0 4px 15px rgba(0,0,0,0.5);
+  box-shadow: 0 8px 24px rgba(0,0,0,0.6);
   border-radius: 6px;
-  z-index: 1000;
+  z-index: 9801;
   display: flex;
   flex-direction: column;
   overflow: hidden;
 }
+
+/* Test inline annotations (view zones above tested lines) */
+.ide-test-zone-header {
+  font-size: 11px;
+  font-style: italic;
+  font-family: var(--font-mono, monospace);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  padding: 2px 10px;
+  pointer-events: none;
+  opacity: 0.85;
+}
+.ide-test-zone-pass {
+  color: #4ec9b0;
+  border-top: 1px dashed rgba(78, 201, 176, 0.25);
+}
+.ide-test-zone-fail {
+  color: #f14c4c;
+  border-top: 1px dashed rgba(241, 76, 76, 0.25);
+}
+/* Subtle background tint on the tested line itself */
+.ide-test-line-pass {
+  background: rgba(78, 201, 176, 0.06);
+}
+.ide-test-line-fail {
+  background: rgba(241, 76, 76, 0.08);
+}
+
 .ide-file-history-header {
   display: flex;
   justify-content: space-between;
@@ -396,7 +482,7 @@
 }
 .ide-file-history-title {
   font-weight: 500;
-  color: #d4d4d4;
+  color: var(--text-primary, #d4d4d4);
   display: flex;
   align-items: center;
   gap: 8px;
@@ -470,7 +556,7 @@
   font-size: 11px;
   font-style: italic;
   font-family: var(--font-mono);
-  color: #9aa0a6;
+  color: #d7ba7d;
   opacity: 0.85;
   white-space: nowrap;
   overflow: hidden;

data/app/controllers/mbeditor/application_controller.rb

@@ -20,7 +20,7 @@ module Mbeditor
         self.class.instance_variable_get(:@workspace_root_cache) ||
           self.class.instance_variable_set(:@workspace_root_cache, begin
             rails_root = Rails.root.to_s
-            out, status = Open3.capture2("git", "-C", rails_root, "rev-parse", "--show-toplevel")
+            out, _err, status = Open3.capture3("git", "-C", rails_root, "rev-parse", "--show-toplevel")
             Pathname.new(status.success? && out.strip.present? ? out.strip : rails_root)
           rescue StandardError
             Rails.root

data/app/controllers/mbeditor/editors_controller.rb

@@ -37,7 +37,8 @@ module Mbeditor
         hamlLintAvailable: haml_lint_available?,
         gitAvailable: git_available?,
         blameAvailable: git_blame_available?,
-        redmineEnabled: Mbeditor.configuration.redmine_enabled == true
+        redmineEnabled: Mbeditor.configuration.redmine_enabled == true,
+        testAvailable: test_available?
       }
     end
 
@@ -213,7 +214,7 @@ module Mbeditor
       end
 
       if RG_AVAILABLE
-        output, = Open3.capture2(*cmd)
+        output, = Open3.capture3(*cmd)
         output.lines.each do |line|
           break if results.length > 30
 
@@ -228,7 +229,7 @@ module Mbeditor
           }
         end
       else
-        output, = Open3.capture2(*cmd)
+        output, = Open3.capture3(*cmd)
         output.lines.each do |line|
           break if results.length > 30
 
@@ -254,7 +255,7 @@ module Mbeditor
 
     # GET /mbeditor/git_status
     def git_status
-      output, status = Open3.capture2("git", "-C", workspace_root.to_s, "status", "--porcelain")
+      output, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "status", "--porcelain")
       branch = GitService.current_branch(workspace_root.to_s) || ""
       files = output.lines.map do |line|
         { status: line[0..1].strip, path: line[3..].strip }
@@ -271,15 +272,15 @@ module Mbeditor
       unless branch
         return render json: { ok: false, error: "Unable to determine current branch" }, status: :unprocessable_entity
       end
-      working_output, working_status = Open3.capture2("git", "-C", repo, "status", "--porcelain")
+      working_output, _err, working_status = Open3.capture3("git", "-C", repo, "status", "--porcelain")
       working_tree = working_status.success? ? parse_porcelain_status(working_output) : []
 
       # Annotate each working-tree file with added/removed line counts
-      numstat_out, = Open3.capture2("git", "-C", repo, "diff", "--numstat", "HEAD")
+      numstat_out, = Open3.capture3("git", "-C", repo, "diff", "--numstat", "HEAD")
       numstat_map  = parse_numstat(numstat_out)
       working_tree = working_tree.map { |f| f.merge(numstat_map.fetch(f[:path], {})) }
 
-      upstream_output, upstream_status = Open3.capture2("git", "-C", repo, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
+      upstream_output, _err, upstream_status = Open3.capture3("git", "-C", repo, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
       upstream_branch = upstream_status.success? ? upstream_output.strip : nil
       upstream_branch = nil unless upstream_branch&.match?(%r{\A[\w./-]+\z})
 
@@ -289,26 +290,26 @@ module Mbeditor
       unpushed_commits = []
 
       if upstream_branch.present?
-        counts_output, counts_status = Open3.capture2("git", "-C", repo, "rev-list", "--left-right", "--count", "HEAD...#{upstream_branch}")
+        counts_output, _err, counts_status = Open3.capture3("git", "-C", repo, "rev-list", "--left-right", "--count", "HEAD...#{upstream_branch}")
         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
 
-        unpushed_output, unpushed_status = Open3.capture2("git", "-C", repo, "diff", "--name-status", "#{upstream_branch}..HEAD")
+        unpushed_output, _err, unpushed_status = Open3.capture3("git", "-C", repo, "diff", "--name-status", "#{upstream_branch}..HEAD")
         if unpushed_status.success?
           unpushed_files   = parse_name_status(unpushed_output)
-          unp_numstat_out, = Open3.capture2("git", "-C", repo, "diff", "--numstat", "#{upstream_branch}..HEAD")
+          unp_numstat_out, = Open3.capture3("git", "-C", repo, "diff", "--numstat", "#{upstream_branch}..HEAD")
           unp_numstat_map  = parse_numstat(unp_numstat_out)
           unpushed_files   = unpushed_files.map { |f| f.merge(unp_numstat_map.fetch(f[:path], {})) }
         end
 
-        unpushed_log_output, unpushed_log_status = Open3.capture2("git", "-C", repo, "log", "#{upstream_branch}..HEAD", "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
+        unpushed_log_output, _err, unpushed_log_status = Open3.capture3("git", "-C", repo, "log", "#{upstream_branch}..HEAD", "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
         unpushed_commits = parse_git_log(unpushed_log_output) if unpushed_log_status.success?
       end
 
-      branch_log_output, branch_log_status = Open3.capture2("git", "-C", repo, "log", "--first-parent", branch, "-n", "100", "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
+      branch_log_output, _err, branch_log_status = Open3.capture3("git", "-C", repo, "log", "--first-parent", branch, "-n", "100", "--pretty=format:%H%x1f%s%x1f%an%x1f%aI%x1e")
       branch_commits = branch_log_status.success? ? parse_git_log(branch_log_output) : []
 
       render json: {
@@ -436,6 +437,32 @@ module Mbeditor
       render json: { error: e.message }, status: :unprocessable_entity
     end
 
+    # POST /mbeditor/test — run tests for the given file
+    def run_test
+      path = resolve_path(params[:path])
+      return render json: { error: "Forbidden" }, status: :forbidden unless path
+
+      relative = relative_path(path)
+      test_file = TestRunnerService.resolve_test_file(workspace_root.to_s, relative)
+      return render json: { error: "No matching test file found for #{relative}" }, status: :not_found unless test_file
+
+      full_test = File.join(workspace_root.to_s, test_file)
+      return render json: { error: "Test file does not exist: #{test_file}" }, status: :not_found unless File.file?(full_test)
+
+      config = Mbeditor.configuration
+      result = TestRunnerService.run(
+        workspace_root.to_s,
+        test_file,
+        framework: config.test_framework&.to_sym,
+        command: config.test_command,
+        timeout: config.test_timeout || 60
+      )
+
+      render json: result.merge(testFile: test_file)
+    rescue StandardError => e
+      render json: { error: e.message, ok: false }, status: :unprocessable_entity
+    end
+
     # POST /mbeditor/format — rubocop -A then return corrected content
     def format_file
       path = resolve_path(params[:path])
@@ -633,7 +660,7 @@ module Mbeditor
               self.class.instance_variable_set(:@git_available_cache, {})
       return cache[key] if cache.key?(key)
       cache[key] = begin
-        _out, status = Open3.capture2("git", "-C", key, "rev-parse", "--is-inside-work-tree")
+        _out, _err, status = Open3.capture3("git", "-C", key, "rev-parse", "--is-inside-work-tree")
         status.success?
       rescue StandardError
         false
@@ -642,6 +669,11 @@ module Mbeditor
 
     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?

data/app/controllers/mbeditor/git_controller.rb

@@ -22,9 +22,13 @@ module Mbeditor
 
       base = params[:base].presence
       head = params[:head].presence
-      valid_sha = /\A[0-9a-fA-F]{1,40}\z/
-      if [base, head].any? { |s| s && !s.match?(valid_sha) }
-        return render json: { error: 'Invalid sha' }, status: :bad_request
+      # '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(
@@ -75,11 +79,11 @@ module Mbeditor
       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, files_status = Open3.capture2(
+      files_output, _err, files_status = Open3.capture3(
         "git", "-C", workspace_root.to_s,
         "diff-tree", "--no-commit-id", "-r", "--name-status", sha
       )
-      numstat_output, numstat_status = Open3.capture2(
+      numstat_output, _err, numstat_status = Open3.capture3(
         "git", "-C", workspace_root.to_s,
         "diff-tree", "--no-commit-id", "-r", "--numstat", sha
       )
@@ -104,7 +108,7 @@ module Mbeditor
         end.compact
       end
 
-      log_output, log_status = Open3.capture2(
+      log_output, _err, log_status = Open3.capture3(
         "git", "-C", workspace_root.to_s,
         "log", "-1", "--pretty=format:%s%x1f%an%x1f%aI", sha
       )
@@ -127,17 +131,17 @@ module Mbeditor
       scope = params[:scope] == 'branch' ? :branch : :local
 
       if scope == :local
-        out, status = Open3.capture2("git", "-C", workspace_root.to_s, "diff", "HEAD")
+        out, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "diff", "HEAD")
         out = status.success? ? out : ""
       else
-        upstream_out, upstream_status = Open3.capture2(
+        upstream_out, _err, upstream_status = Open3.capture3(
           "git", "-C", workspace_root.to_s,
           "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, status = Open3.capture2("git", "-C", workspace_root.to_s, "diff", "#{upstream}..HEAD")
+          out, _err, status = Open3.capture3("git", "-C", workspace_root.to_s, "diff", "#{upstream}..HEAD")
           out = status.success? ? out : ""
         else
           out = ""

data/app/services/mbeditor/git_diff_service.rb

@@ -28,6 +28,9 @@ module Mbeditor
     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

data/app/services/mbeditor/git_service.rb

@@ -15,9 +15,11 @@ module Mbeditor
     SAFE_GIT_REF = %r{\A[\w./-]+\z}
 
     # Run an arbitrary git command inside +repo_path+.
-    # Returns [stdout, Process::Status].
+    # 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)
-      Open3.capture2("git", "-C", 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.

data/app/services/mbeditor/test_runner_service.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+require "shellwords"
+
+module Mbeditor
+  # Runs a Ruby test file (Minitest or RSpec) and parses the output into a
+  # structured result suitable for the editor UI.
+  #
+  # Follows the same process-group kill pattern used by the lint endpoint to
+  # enforce a configurable timeout.
+  module TestRunnerService
+    module_function
+
+    # Run the test file at +test_path+ inside +repo_path+.
+    # Returns a Hash:
+    #   {
+    #     ok:       true/false,
+    #     summary:  { total:, passed:, failed:, errored:, skipped:, duration: },
+    #     tests:    [{ name:, status:, line:, message: }],
+    #     raw:      String   # full stdout+stderr for fallback display
+    #   }
+    def run(repo_path, test_path, framework: nil, command: nil, timeout: 60)
+      framework = detect_framework(repo_path, test_path) if framework.nil?
+      return error_result("Could not detect test framework") unless framework
+
+      cmd = build_command(repo_path, test_path, framework, command)
+      raw, timed_out = execute_with_timeout(repo_path, cmd, timeout)
+
+      return error_result("Test run timed out after #{timeout} seconds") if timed_out
+
+      tests, summary = parse_output(raw, framework)
+      {
+        ok: true,
+        framework: framework.to_s,
+        summary: summary,
+        tests: tests,
+        raw: raw
+      }
+    rescue StandardError => e
+      error_result(e.message)
+    end
+
+    # Given a source file path, resolve it to its matching test/spec file.
+    # If the file is already a test/spec file, return it as-is.
+    def resolve_test_file(repo_path, relative_path)
+      return relative_path if test_file?(relative_path)
+
+      candidates = test_file_candidates(relative_path)
+      candidates.find { |c| File.exist?(File.join(repo_path, c)) }
+    end
+
+    def test_file?(path)
+      path.match?(%r{(^|/)test/.*_test\.rb$}) ||
+        path.match?(%r{(^|/)spec/.*_spec\.rb$}) ||
+        path.end_with?("_test.rb") ||
+        path.end_with?("_spec.rb")
+    end
+
+    def test_file_candidates(relative_path)
+      return [] unless relative_path.end_with?(".rb")
+
+      basename = File.basename(relative_path, ".rb")
+      dir_parts = relative_path.split("/")
+
+      candidates = []
+
+      # app/models/user.rb -> test/models/user_test.rb
+      if dir_parts[0] == "app" && dir_parts.length > 1
+        sub_path = dir_parts[1..].join("/")
+        sub_dir = File.dirname(sub_path)
+        candidates << File.join("test", sub_dir, "#{basename}_test.rb")
+        candidates << File.join("spec", sub_dir, "#{basename}_spec.rb")
+      end
+
+      # lib/foo.rb -> test/lib/foo_test.rb or test/foo_test.rb
+      if dir_parts[0] == "lib"
+        sub_path = dir_parts[1..].join("/")
+        sub_dir = File.dirname(sub_path)
+        candidates << File.join("test", "lib", sub_dir, "#{basename}_test.rb")
+        candidates << File.join("test", sub_dir, "#{basename}_test.rb")
+        candidates << File.join("spec", "lib", sub_dir, "#{basename}_spec.rb")
+      end
+
+      # Fallback: test/<basename>_test.rb
+      candidates << File.join("test", "#{basename}_test.rb")
+      candidates << File.join("spec", "#{basename}_spec.rb")
+
+      candidates.uniq
+    end
+
+    def detect_framework(repo_path, test_path)
+      return :rspec if test_path.end_with?("_spec.rb")
+      return :minitest if test_path.end_with?("_test.rb")
+
+      # Check project-level hints
+      return :rspec if File.exist?(File.join(repo_path, ".rspec"))
+      return :rspec if File.exist?(File.join(repo_path, "spec"))
+
+      :minitest if File.exist?(File.join(repo_path, "test"))
+    end
+
+    def build_command(repo_path, test_path, framework, custom_command)
+      full_path = File.join(repo_path, test_path)
+
+      if custom_command.present?
+        tokens = Shellwords.split(custom_command)
+        return tokens + [full_path]
+      end
+
+      case framework.to_sym
+      when :rspec
+        bin = File.join(repo_path, "bin", "rspec")
+        cmd = File.exist?(bin) ? [bin] : ["bundle", "exec", "rspec"]
+        cmd + ["--format", "json", full_path]
+      when :minitest
+        bin = File.join(repo_path, "bin", "rails")
+        if File.exist?(bin)
+          [bin, "test", full_path]
+        else
+          ["bundle", "exec", "ruby", "-Itest", full_path]
+        end
+      else
+        ["bundle", "exec", "ruby", "-Itest", full_path]
+      end
+    end
+
+    def execute_with_timeout(repo_path, cmd, timeout)
+      raw = +""
+      timed_out = false
+
+      Open3.popen3(*cmd, chdir: repo_path, pgroup: true) do |stdin, stdout, stderr, wait_thr|
+        stdin.close
+
+        timer = Thread.new do
+          sleep timeout
+          timed_out = true
+          Process.kill("-KILL", wait_thr.pid)
+        rescue Errno::ESRCH
+          nil
+        end
+
+        out = stdout.read
+        err = stderr.read
+        raw = out.to_s + err.to_s
+        wait_thr.value
+        timer.kill
+      end
+
+      [raw, timed_out]
+    end
+
+    def parse_output(raw, framework)
+      case framework.to_sym
+      when :rspec
+        parse_rspec_output(raw)
+      when :minitest
+        parse_minitest_output(raw)
+      else
+        [[], empty_summary]
+      end
+    end
+
+    def parse_rspec_output(raw)
+      # RSpec with --format json embeds JSON in the output
+      json_match = raw.match(/(\{.*"summary_line".*\})/m)
+      if json_match
+        data = JSON.parse(json_match[1])
+        summary = {
+          total: data.dig("summary", "example_count") || 0,
+          passed: (data.dig("summary", "example_count") || 0) - (data.dig("summary", "failure_count") || 0) - (data.dig("summary", "pending_count") || 0),
+          failed: data.dig("summary", "failure_count") || 0,
+          errored: 0,
+          skipped: data.dig("summary", "pending_count") || 0,
+          duration: data.dig("summary", "duration")&.round(3)
+        }
+        tests = (data["examples"] || []).map do |ex|
+          {
+            name: ex["full_description"] || ex["description"],
+            status: ex["status"] == "passed" ? "pass" : (ex["status"] == "pending" ? "skip" : "fail"),
+            line: ex.dig("line_number"),
+            message: ex.dig("exception", "message")
+          }
+        end
+        [tests, summary]
+      else
+        parse_minitest_output(raw) # fallback to text parsing
+      end
+    rescue JSON::ParserError
+      parse_minitest_output(raw)
+    end
+
+    def parse_minitest_output(raw)
+      tests = []
+      lines = raw.lines
+
+      # Parse individual test results from Minitest output
+      lines.each_with_index do |line, idx|
+        # Failure/Error blocks: "  1) Failure:\nTestName#method [file:line]:\nmessage"
+        if line.match?(/^\s+\d+\)\s+(Failure|Error):/)
+          name_line = lines[idx + 1]
+          if name_line
+            name = name_line.strip.split(" [").first
+            line_num = name_line[/:(\d+)\]/, 1]&.to_i
+            # Collect message lines until next blank or numbered item
+            msg_lines = []
+            (idx + 2...lines.length).each do |j|
+              break if lines[j].strip.empty? || lines[j].match?(/^\s+\d+\)\s+/)
+              msg_lines << lines[j].strip
+            end
+            tests << {
+              name: name,
+              status: line.include?("Error") ? "error" : "fail",
+              line: line_num,
+              message: msg_lines.join("\n")
+            }
+          end
+        end
+      end
+
+      summary = empty_summary
+
+      # Parse summary line: "X runs, Y assertions, Z failures, W errors, V skips"
+      # or "X tests, Y assertions, Z failures, W errors, V skips"
+      summary_line = lines.find { |l| l.match?(/\d+ (runs|tests), \d+ assertions/) }
+      if summary_line
+        nums = summary_line.scan(/\d+/).map(&:to_i)
+        summary[:total]   = nums[0] || 0
+        summary[:failed]  = nums[2] || 0
+        summary[:errored] = nums[3] || 0
+        summary[:skipped] = nums[4] || 0
+        summary[:passed]  = summary[:total] - summary[:failed] - summary[:errored] - summary[:skipped]
+      end
+
+      # Parse timing: "Finished in 0.123456s"
+      time_line = lines.find { |l| l.match?(/Finished in [\d.]+s/) }
+      if time_line
+        summary[:duration] = time_line[/([\d.]+)s/, 1]&.to_f&.round(3)
+      end
+
+      [tests, summary]
+    end
+
+    def empty_summary
+      { total: 0, passed: 0, failed: 0, errored: 0, skipped: 0, duration: nil }
+    end
+
+    def error_result(message)
+      {
+        ok: false,
+        error: message,
+        summary: empty_summary,
+        tests: [],
+        raw: ""
+      }
+    end
+  end
+end

data/config/routes.rb

@@ -24,6 +24,7 @@ Mbeditor::Engine.routes.draw do
   post   'lint',            to: 'editors#lint'
   post   'quick_fix',       to: 'editors#quick_fix'
   post   'format',          to: 'editors#format_file'
+  post   'test',            to: 'editors#run_test'
 
   # ── Git & Code Review ──────────────────────────────────────────────────────
   get 'git/diff',           to: 'git#diff'

data/lib/mbeditor/configuration.rb

@@ -1,7 +1,8 @@
 module Mbeditor
   class Configuration
     attr_accessor :allowed_environments, :workspace_root, :excluded_paths, :rubocop_command,
-                  :redmine_enabled, :redmine_url, :redmine_api_key
+                  :redmine_enabled, :redmine_url, :redmine_api_key,
+                  :test_framework, :test_command, :test_timeout
 
     def initialize
       @allowed_environments = [:development]
@@ -11,6 +12,9 @@ module Mbeditor
       @redmine_enabled  = false
       @redmine_url      = nil
       @redmine_api_key  = nil
+      @test_framework   = nil # :minitest or :rspec — auto-detected when nil
+      @test_command     = nil # e.g. "bundle exec ruby -Itest" or "bundle exec rspec"
+      @test_timeout     = 60  # seconds
     end
   end
 end