mbeditor 0.2.2

data/app/services/mbeditor/ruby_definition_service.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "find"
+require "ripper"
+
+module Mbeditor
+  # Searches .rb files in a workspace for definitions of a named Ruby method
+  # using Ripper's AST parser (no subprocesses).
+  #
+  # Returns an array of hashes, each describing one definition site:
+  #   {
+  #     file:      String,  # workspace-relative path
+  #     line:      Integer, # 1-based line number of the `def` keyword
+  #     signature: String,  # trimmed source text of the def line
+  #     comments:  String   # leading # comment lines immediately above the def (may be empty)
+  #   }
+  #
+  # Usage:
+  #   results = RubyDefinitionService.call(workspace_root, "my_method",
+  #                                        excluded_dirnames: %w[tmp .git])
+  class RubyDefinitionService
+    MAX_RESULTS = 20
+    MAX_COMMENT_LOOKAHEAD = 15
+
+    def self.call(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [])
+      new(workspace_root, symbol,
+          excluded_dirnames: excluded_dirnames,
+          excluded_paths: excluded_paths).call
+    end
+
+    def initialize(workspace_root, symbol, excluded_dirnames: [], excluded_paths: [])
+      @workspace_root   = workspace_root.to_s.chomp("/")
+      @symbol           = symbol
+      @excluded_dirnames = Array(excluded_dirnames)
+      @excluded_paths    = Array(excluded_paths)
+    end
+
+    def call
+      results = []
+
+      Find.find(@workspace_root) do |path|
+        # Prune excluded directories
+        if File.directory?(path)
+          dirname = File.basename(path)
+          rel_dir = relative_path(path)
+          if path != @workspace_root && excluded_dir?(dirname, rel_dir)
+            Find.prune
+          end
+          next
+        end
+
+        next unless path.end_with?(".rb")
+
+        rel = relative_path(path)
+        next if excluded_rel_path?(rel, File.basename(path))
+
+        begin
+          source = File.read(path, encoding: "UTF-8", invalid: :replace, undef: :replace)
+          lines  = source.split("\n", -1)
+          hits   = find_definitions(source, @symbol)
+
+          hits.each do |def_line|
+            results << {
+              file:      rel,
+              line:      def_line,
+              signature: (lines[def_line - 1] || "").strip,
+              comments:  extract_comments(lines, def_line)
+            }
+            return results if results.length >= MAX_RESULTS
+          end
+        rescue StandardError
+          # Malformed file or unreadable; skip silently
+        end
+      end
+
+      results
+    end
+
+    private
+
+    # Parse `source` with Ripper and return sorted array of 1-based line numbers
+    # where a method named `symbol` is defined (handles both `def foo` and `def self.foo`).
+    def find_definitions(source, symbol)
+      sexp = Ripper.sexp(source)
+      return [] unless sexp
+
+      lines = []
+      walk(sexp, symbol, lines)
+      lines.sort
+    end
+
+    # Recursive sexp walker.  Ripper represents:
+    #   def foo(...)   as  [:def,  [:@ident, "foo",  [line, col]], ...]
+    #   def self.foo   as  [:defs, receiver, [:@ident, "foo", [line, col]], ...]
+    def walk(node, symbol, lines)
+      return unless node.is_a?(Array)
+
+      case node[0]
+      when :def
+        # node[1] is the method name node: [:@ident, "name", [line, col]]
+        name_node = node[1]
+        if name_node.is_a?(Array) && name_node[1].to_s == symbol
+          line = name_node[2]&.first
+          lines << line if line
+        end
+        # Still walk children in case of nested defs
+        node[1..].each { |child| walk(child, symbol, lines) }
+
+      when :defs
+        # node[3] is the method name node for `def self.foo`
+        name_node = node[3]
+        if name_node.is_a?(Array) && name_node[1].to_s == symbol
+          line = name_node[2]&.first
+          lines << line if line
+        end
+        node[1..].each { |child| walk(child, symbol, lines) }
+
+      else
+        node.each { |child| walk(child, symbol, lines) }
+      end
+    end
+
+    # Walk backwards from def_line collecting contiguous # comment lines.
+    # Stops on blank lines or non-comment lines.
+    def extract_comments(lines, def_line)
+      comment_lines = []
+      idx = def_line - 2  # 0-based index of the line immediately above the def
+
+      MAX_COMMENT_LOOKAHEAD.times do
+        break if idx < 0
+
+        line = lines[idx].to_s.strip
+        break if line.empty?
+        break unless line.start_with?("#")
+
+        comment_lines.unshift(line)
+        idx -= 1
+      end
+
+      comment_lines.join("\n")
+    end
+
+    def relative_path(full_path)
+      full_path.to_s.delete_prefix(@workspace_root).delete_prefix("/")
+    end
+
+    def excluded_dir?(dirname, rel_dir)
+      @excluded_dirnames.include?(dirname) ||
+        @excluded_paths.any? do |pattern|
+          if pattern.include?("/")
+            rel_dir == pattern || rel_dir.start_with?("#{pattern}/")
+          else
+            dirname == pattern
+          end
+        end
+    end
+
+    def excluded_rel_path?(rel, name)
+      @excluded_paths.any? do |pattern|
+        if pattern.include?("/")
+          rel == pattern || rel.start_with?("#{pattern}/")
+        else
+          name == pattern || rel.split("/").include?(pattern)
+        end
+      end
+    end
+  end
+end

data/app/services/mbeditor/test_runner_service.rb

@@ -0,0 +1,286 @@
+# 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", "--verbose", full_path]
+        else
+          ["bundle", "exec", "ruby", "-Itest", full_path, "--verbose"]
+        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)
+      lines = raw.lines
+
+      # First pass: collect per-test results from verbose output.
+      # Verbose format (--verbose): "ClassName#test_name = N.NNN s = [./F/E/S]"
+      verbose_results = {}
+      lines.each do |line|
+        m = line.match(/\A([\w:]+#\w+)\s+=\s+[\d.]+\s+s\s+=\s+([.FES])\s*\z/)
+        next unless m
+
+        status = case m[2]
+                 when "." then "pass"
+                 when "F" then "fail"
+                 when "E" then "error"
+                 when "S" then "skip"
+                 end
+        verbose_results[m[1]] = { name: m[1], status: status, line: nil, message: nil }
+      end
+
+      # Second pass: parse failure/error blocks for messages and line numbers.
+      # Format: "  1) Failure:\nTestName#method [file:line]:\nmessage"
+      failure_entries = []
+      lines.each_with_index do |line, idx|
+        next unless line.match?(/^\s+\d+\)\s+(Failure|Error):/)
+
+        name_line = lines[idx + 1]
+        next unless name_line
+
+        name = name_line.strip.split(" [").first.chomp(":")
+        line_num = name_line[/:(\d+)\]/, 1]&.to_i
+        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
+
+        entry = {
+          name: name,
+          status: line.include?("Error") ? "error" : "fail",
+          line: line_num,
+          message: msg_lines.join("\n")
+        }
+
+        if verbose_results.key?(name)
+          verbose_results[name][:line]    = line_num
+          verbose_results[name][:message] = msg_lines.join("\n")
+        else
+          failure_entries << entry
+        end
+      end
+
+      # Build final tests list: verbose entries first (sorted by name for stability),
+      # then any failure entries not already covered by verbose output.
+      tests = verbose_results.values + failure_entries
+
+      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/app/views/layouts/mbeditor/application.html.erb

@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta name="turbo-visit-control" content="reload" />
+  <meta name="theme-color" content="#1e1e2e" />
+  <meta name="mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <% pwa_base = request.script_name.to_s.sub(%r{/$}, '') %>
+  <link rel="manifest" href="<%= "#{pwa_base}/manifest.webmanifest" %>" />
+  <script>
+    if ('serviceWorker' in navigator) {
+      navigator.serviceWorker.register('<%= json_escape("#{pwa_base}/sw.js") %>', { scope: '<%= json_escape("#{pwa_base}/") %>' });
+    }
+  </script>
+  <title>Mbeditor — <%= Rails.root.basename %></title>
+
+  <!-- ── Fonts and Styles ──────────────────────────────── -->
+  <%= stylesheet_link_tag "fontawesome.min", media: "all" %>
+  <%= stylesheet_link_tag "mbeditor/application", media: "all" %>
+
+  <!-- ── Vendor JS (order matters) ─────────────────────── -->
+  <script src="<%= asset_path('react.min.js') %>"></script>
+  <script src="<%= asset_path('react-dom.min.js') %>"></script>
+  <script src="<%= asset_path('axios.min.js') %>"></script>
+  <script src="<%= asset_path('lodash.min.js') %>"></script>
+  <script src="<%= asset_path('minisearch.min.js') %>"></script>
+  <script src="<%= asset_path('marked.min.js') %>"></script>
+  <!-- ── Monaco loader ─────────────────────────────────── -->
+  <% base_path = request.script_name.to_s.sub(%r{/$}, '') %>
+  <script>var require = { paths: { vs: '<%= json_escape("#{base_path}/monaco-editor/vs") %>', 'monaco-vim': '<%= json_escape(asset_path("monaco-vim.js").sub(/\.js$/, "")) %>', 'monaco-editor/esm/vs': '<%= json_escape("#{base_path}/monaco-editor/vs") %>' } };</script>
+  <script src="<%= "#{base_path}/monaco-editor/vs/loader.js" %>"></script>
+  <!-- ── Emmet + Extra themes (non-AMD, load before app) ── -->
+  <script src="<%= asset_path('emmet.js') %>"></script>
+  <script src="<%= asset_path('monaco-themes-bundle.js') %>"></script>
+</head>
+<body data-rails-root="<%= Rails.root.to_s %>" data-mbeditor-version="<%= Mbeditor::VERSION %>">
+  <script>
+    window.MBEDITOR_BASE_PATH = "<%= json_escape(base_path) %>";
+
+    // Monaco's restoreViewState cancels its own internal rendering promises and
+    // those cancellations surface as "Canceled: Canceled" unhandled rejections.
+    // This is a known Monaco quirk — the cancellation is intentional and benign.
+    // Suppress it here so it doesn't pollute the console.
+    window.addEventListener('unhandledrejection', function(event) {
+      if (event.reason && event.reason.name === 'Canceled' && event.reason.message === 'Canceled') {
+        event.preventDefault();
+      }
+    });
+  </script>
+
+  <div id="mbeditor-root">
+    <%= yield %>
+  </div>
+
+  <script>
+    window.MonacoEnvironment = {
+      getWorkerUrl: function(workerId, label) {
+        var base = window.MBEDITOR_BASE_PATH || '';
+        if (label === 'typescript' || label === 'javascript') {
+          return base + '/ts_worker.js';
+        }
+        return base + '/monaco_worker.js';
+      }
+    };
+
+    // Load Prettier scripts sequentially with define temporarily hidden so their
+    // UMD wrapper sets window.prettier / window.prettierPlugins instead of
+    // registering as AMD modules via Monaco's loader.  Then load Monaco and the
+    // app once all Prettier scripts are ready.
+    (function() {
+      var prettierScripts = [
+        '<%= asset_path("prettier-standalone.js") %>',
+        '<%= asset_path("prettier-plugin-babel.js") %>',
+        '<%= asset_path("prettier-plugin-estree.js") %>',
+        '<%= asset_path("prettier-plugin-html.js") %>',
+        '<%= asset_path("prettier-plugin-postcss.js") %>',
+        '<%= asset_path("prettier-plugin-markdown.js") %>'
+      ];
+
+      function loadSequential(srcs, done) {
+        if (!srcs.length) return done();
+        var s = document.createElement('script');
+        s.src = srcs[0];
+        s.onload = function() { loadSequential(srcs.slice(1), done); };
+        document.head.appendChild(s);
+      }
+
+      var _define = window.define;
+      window.define = undefined;
+
+      loadSequential(prettierScripts, function() {
+        window.define = _define;
+
+        // Wait for Monaco to load before initializing application scripts
+        require(['vs/editor/editor.main'], function() {
+          // Register custom themes from the vendored bundle
+          if (window.MBEDITOR_CUSTOM_THEMES && window.monaco) {
+            Object.keys(window.MBEDITOR_CUSTOM_THEMES).forEach(function(id) {
+              window.monaco.editor.defineTheme(id, window.MBEDITOR_CUSTOM_THEMES[id]);
+            });
+          }
+          var appScript = document.createElement('script');
+          appScript.src = '<%= asset_path("mbeditor/application.js") %>';
+          appScript.onload = function() {
+            var root = document.getElementById('mbeditor-root');
+            if (window.MbeditorApp && window.ReactDOM) {
+              window.ReactDOM.render(React.createElement(window.MbeditorApp), root);
+            } else {
+              console.error("Failed to mount: MbeditorApp or ReactDOM is undefined.");
+            }
+          };
+          document.body.appendChild(appScript);
+        });
+      });
+    })();
+  </script>
+</body>
+</html>

data/app/views/mbeditor/editors/index.html.erb

@@ -0,0 +1 @@
+<!-- Mounted automatically by layout script -->

data/config/initializers/assets.rb

@@ -0,0 +1,9 @@
+# Be sure to restart your server when you modify this file.
+
+# Version of your assets, change this if you want to expire all your assets.
+if Rails.application.config.respond_to?(:assets)
+	Rails.application.config.assets.version = "1.0"
+end
+
+# Add additional assets to the asset load path.
+# Rails.application.config.assets.paths << Emoji.images_path

data/config/routes.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+Mbeditor::Engine.routes.draw do
+  root to: 'editors#index'
+
+  get    'ping',            to: 'editors#ping'
+  get    'workspace',       to: 'editors#workspace'
+  get    'files',           to: 'editors#files'
+  get    'file',            to: 'editors#show'
+  get    'raw',             to: 'editors#raw'
+  post   'file',            to: 'editors#save'
+  post   'create_file',     to: 'editors#create_file'
+  post   'create_dir',      to: 'editors#create_dir'
+  patch  'rename',          to: 'editors#rename'
+  delete 'delete',          to: 'editors#destroy_path'
+  get    'state',           to: 'editors#state'
+  post   'state',           to: 'editors#save_state'
+  get    'search',          to: 'editors#search'
+  get    'definition',      to: 'editors#definition'
+  get    'git_info',        to: 'editors#git_info'
+  get    'git_status',      to: 'editors#git_status'
+  get    'manifest.webmanifest',            to: 'editors#pwa_manifest',   format: false
+  get    'sw.js',                           to: 'editors#pwa_sw',         format: false
+  get    'mbeditor-icon.svg',               to: 'editors#pwa_icon',       format: false
+  get    'monaco_worker.js',                to: 'editors#monaco_worker',  format: false
+  get    'ts_worker.js',                    to: 'editors#ts_worker',      format: false
+  get    'monaco-editor/*asset_path',       to: 'editors#monaco_asset', format: false
+  get    'min-maps/*asset_path',            to: 'editors#monaco_asset', format: false
+  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'
+  get 'git/blame',          to: 'git#blame'
+  get 'git/file_history',   to: 'git#file_history'
+  get 'git/commit_graph',   to: 'git#commit_graph'
+  get 'git/commit_detail',  to: 'git#commit_detail'
+  get 'git/combined_diff',  to: 'git#combined_diff'
+
+  # Redmine integration (enabled via config.mbeditor.redmine_enabled)
+  get 'redmine/issue/:id', to: 'git#redmine_issue', as: :redmine_issue
+end

data/lib/mbeditor/configuration.rb

@@ -0,0 +1,22 @@
+module Mbeditor
+  class Configuration
+    attr_accessor :allowed_environments, :workspace_root, :excluded_paths, :rubocop_command,
+                  :redmine_enabled, :redmine_url, :redmine_api_key, :redmine_ticket_source,
+                  :test_framework, :test_command, :test_timeout,
+                  :authenticate_with
+
+    def initialize
+      @allowed_environments = [:development]
+      @workspace_root = nil
+      @excluded_paths = %w[.git tmp log node_modules .bundle coverage vendor/bundle]
+      @rubocop_command = "rubocop"
+      @redmine_enabled       = false
+      @redmine_url           = nil
+      @redmine_api_key       = nil
+      @redmine_ticket_source = :commit # :commit (scan commit messages) or :branch (leading digits of branch name)
+      @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