omamori 0.1.2 → 0.2.0

data/lib/omamori/doctor.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'ai_settings'
+
+module Omamori
+  # `omamori doctor`: checks that the configured classifier and reporters can be reached, by sending each
+  # one small request, and says how to fix what is missing.
+  class Doctor
+    REPORTER_PROBE = 'This is a connectivity check by `omamori doctor`. There is no code to review. ' \
+                     'Return {"security_risks": []}.'
+    CLASSIFIER_PROBE_STATE = "puts 'hello'"
+    CLASSIFIER_PROBE_QUESTIONS = { ruby: 'Is this Ruby code?' }.freeze
+    CLI_INSTALL = {
+      'claude_code' => 'Install Claude Code (npm install -g @anthropic-ai/claude-code) and log in with `claude`',
+      'codex' => 'Install the Codex CLI (npm install -g @openai/codex) and log in with `codex login`'
+    }.freeze
+
+    def initialize(settings, json_schema:)
+      @settings = settings
+      @json_schema = json_schema
+    end
+
+    # Returns true when every role answered
+    def run
+      puts "Settings: #{@settings.describe}"
+      results = []
+      results << check('classifier', @settings.classifier) { check_classifier } if @settings.classifier?
+      results << check('reporter', @settings.reporter) { check_reporter(@settings.reporter) }
+      if @settings.reporter_fallback
+        results << check('reporter.fallback', @settings.reporter_fallback) { check_reporter(@settings.reporter_fallback) }
+      end
+      ok = results.all?
+      puts ok ? 'All checks passed. Try `omamori scan --base main`.' : 'Some checks failed. Fix them and run `omamori doctor` again.'
+      ok
+    end
+
+    private
+
+    def check(role, role_settings)
+      label = "#{role} (#{[role_settings['provider'], role_settings['model']].compact.join('/')})"
+      puts "Checking #{label}..."
+      problem = yield
+      if problem
+        puts "  NG: #{problem}"
+        false
+      else
+        puts '  OK'
+        true
+      end
+    rescue StandardError => e
+      puts "  NG: #{e.class}: #{e.message}"
+      hint = credential_hint(role_settings)
+      puts "  #{hint}" if hint
+      false
+    end
+
+    # Returns nil when it works, or what is wrong
+    def check_classifier
+      answers = @settings.build_classifier_client.classify(CLASSIFIER_PROBE_STATE, CLASSIFIER_PROBE_QUESTIONS)
+      return nil unless answers.values.include?(nil)
+
+      "The classifier gave no answer. #{credential_hint(@settings.classifier)}".strip
+    end
+
+    def check_reporter(role_settings)
+      provider = role_settings['provider']
+      if AISettings::CLI_REPORTERS.include?(provider)
+        command = role_settings['command'] || (provider == 'claude_code' ? 'claude' : 'codex')
+        return "'#{command}' was not found. #{CLI_INSTALL[provider]}" unless command_exists?(command)
+      end
+
+      result = @settings.build_llm_client(role_settings).analyze(REPORTER_PROBE, @json_schema, model: role_settings['model'])
+      return nil if result
+
+      "The reporter gave no usable answer (see the warning above). #{credential_hint(role_settings)}".strip
+    end
+
+    def credential_hint(role_settings)
+      provider = role_settings['provider']
+      return "#{CLI_INSTALL[provider]}." if CLI_INSTALL.key?(provider)
+
+      env = AISettings.api_key_env(provider)
+      return nil unless env
+      return nil if role_settings['api_key'] || !ENV[env].to_s.empty?
+
+      "#{env} is not set."
+    end
+
+    def command_exists?(command)
+      return File.executable?(command) if command.include?(File::SEPARATOR)
+
+      ENV['PATH'].to_s.split(File::PATH_SEPARATOR).any? { |dir| File.executable?(File.join(dir, command)) }
+    end
+  end
+end

data/lib/omamori/parallel.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Omamori
+  # Minimal thread pool: maps items with at most `concurrency` threads, keeping order.
+  module Parallel
+    def self.map(items, concurrency)
+      queue = Queue.new
+      items.each_with_index { |item, index| queue << [item, index] }
+      results = Array.new(items.size)
+      workers = Array.new([concurrency, items.size].min) do
+        Thread.new do
+          loop do
+            item, index = queue.pop(true)
+            results[index] = yield(item)
+          end
+        rescue ThreadError
+          # queue is empty
+        end
+      end
+      workers.each(&:join)
+      results
+    end
+  end
+end

data/lib/omamori/report_generator/console_formatter.rb

@@ -6,30 +6,30 @@ module Omamori
   module ReportGenerator
     class ConsoleFormatter
       SEVERITY_COLORS = {
-        "Critical" => :red,
-        "High" => :red,
-        "Medium" => :yellow,
-        "Low" => :blue,
-        "Info" => :green,
+        'Critical' => :red,
+        'High' => :red,
+        'Medium' => :yellow,
+        'Low' => :blue,
+        'Info' => :green
       }.freeze
 
       def format(combined_results)
-        output = ""
+        output = ''
 
         # Format AI Analysis Results
-        ai_risks = combined_results && combined_results["ai_security_risks"] ? combined_results["ai_security_risks"] : []
+        ai_risks = combined_results && combined_results['ai_security_risks'] ? combined_results['ai_security_risks'] : []
         if !ai_risks.empty?
           output += "--- AI Analysis Results ---\n".colorize(:bold)
           ai_risks.each do |risk|
-            severity_color = SEVERITY_COLORS[risk["severity"]] || :white
+            severity_color = SEVERITY_COLORS[risk['severity']] || :white
             # Use "Unknown Type" if risk["type"] is nil
-            risk_type = risk["type"] || "Unknown Type"
+            risk_type = risk['type'] || 'Unknown Type'
             output += "  - Type: #{risk_type.colorize(severity_color)}\n"
-            output += "    Severity: #{risk["severity"].colorize(severity_color)}\n"
-            output += "    Location: #{risk["location"]}\n"
-            output += "    Details: #{risk["details"]}\n"
+            output += "    Severity: #{risk['severity'].colorize(severity_color)}\n"
+            output += "    Location: #{risk['location']}\n"
+            output += "    Details: #{risk['details']}\n"
             output += "    Code Snippet:\n"
-            output += format_code_snippet(risk["code_snippet"])
+            output += format_code_snippet(risk['code_snippet'])
             output += "\n"
           end
         else
@@ -39,22 +39,22 @@ module Omamori
         output += "\n"
 
         # Format Static Analysis Results
-        static_results = combined_results && combined_results["static_analysis_results"] ? combined_results["static_analysis_results"] : {}
+        static_results = combined_results && combined_results['static_analysis_results'] ? combined_results['static_analysis_results'] : {}
         output += "--- Static Analysis Results ---\n".colorize(:bold)
 
         # Format Brakeman Results
-        brakeman_result = static_results["brakeman"]
+        brakeman_result = static_results['brakeman']
         if brakeman_result
           output += "Brakeman:\n".colorize(:underline)
-          if brakeman_result["warnings"] && !brakeman_result["warnings"].empty?
-            brakeman_result["warnings"].each do |warning|
-              severity_color = SEVERITY_COLORS[warning["confidence"]] || :white # Map Brakeman confidence to severity color
-              output += "    - Warning Type: #{warning["warning_type"].colorize(severity_color)}\n"
-              output += "      Message: #{warning["message"]}\n"
-              output += "      File: #{warning["file"]}\n"
-              output += "      Line: #{warning["line"]}\n"
-              output += "      Code: #{warning["code"]}\n"
-              output += "      Link: #{warning["link"]}\n"
+          if brakeman_result['warnings'] && !brakeman_result['warnings'].empty?
+            brakeman_result['warnings'].each do |warning|
+              severity_color = SEVERITY_COLORS[warning['confidence']] || :white # Map Brakeman confidence to severity color
+              output += "    - Warning Type: #{warning['warning_type'].colorize(severity_color)}\n"
+              output += "      Message: #{warning['message']}\n"
+              output += "      File: #{warning['file']}\n"
+              output += "      Line: #{warning['line']}\n"
+              output += "      Code: #{warning['code']}\n"
+              output += "      Link: #{warning['link']}\n"
               output += "    \n"
             end
           else
@@ -66,27 +66,27 @@ module Omamori
         output += "\n"
 
         # Format Bundler-Audit Results
-        bundler_audit_result = static_results["bundler_audit"]
-        if bundler_audit_result && bundler_audit_result["scan"] && bundler_audit_result["scan"]["results"]
+        bundler_audit_result = static_results['bundler_audit']
+        if bundler_audit_result && bundler_audit_result['scan'] && bundler_audit_result['scan']['results']
           output += "Bundler-Audit:\n".colorize(:underline)
-          scan_results = bundler_audit_result["scan"]["results"]
+          scan_results = bundler_audit_result['scan']['results']
 
           # Format vulnerabilities (type "unpatched_gem")
-          vulnerabilities = scan_results.select { |result| result["type"] == "unpatched_gem" }
+          vulnerabilities = scan_results.select { |result| result['type'] == 'unpatched_gem' }
           if !vulnerabilities.empty?
             output += "  Vulnerabilities:\n".colorize(:bold)
             vulnerabilities.each do |vulnerability_entry|
-              advisory = vulnerability_entry["advisory"]
-              gem_info = vulnerability_entry["gem"]
-              severity_color = SEVERITY_COLORS[advisory["criticality"]] || :white # Map criticality to severity color
-              output += "    - ID: #{advisory["id"].colorize(severity_color)}\n"
-              output += "      Gem: #{gem_info["name"]} (#{gem_info["version"]})\n" # Include version
-              output += "      Title: #{advisory["title"]}\n"
-              output += "      URL: #{advisory["url"]}\n"
-              output += "      Criticality: #{advisory["criticality"].colorize(severity_color)}\n"
-              output += "      Description: #{advisory["description"]}\n"
-              output += "      Patched Versions: #{advisory["patched_versions"].join(', ')}\n"
-              output += "      Advisory Date: #{advisory["date"]}\n" # Use "date" key from advisory
+              advisory = vulnerability_entry['advisory']
+              gem_info = vulnerability_entry['gem']
+              severity_color = SEVERITY_COLORS[advisory['criticality']] || :white # Map criticality to severity color
+              output += "    - ID: #{advisory['id'].colorize(severity_color)}\n"
+              output += "      Gem: #{gem_info['name']} (#{gem_info['version']})\n" # Include version
+              output += "      Title: #{advisory['title']}\n"
+              output += "      URL: #{advisory['url']}\n"
+              output += "      Criticality: #{advisory['criticality'].colorize(severity_color)}\n"
+              output += "      Description: #{advisory['description']}\n"
+              output += "      Patched Versions: #{advisory['patched_versions'].join(', ')}\n"
+              output += "      Advisory Date: #{advisory['date']}\n" # Use "date" key from advisory
               output += "\n"
             end
           else
@@ -107,8 +107,14 @@ module Omamori
 
         # Add summary before scan complete
         ai_risk_count = ai_risks.length
-        brakeman_warning_count = brakeman_result && brakeman_result["warnings"] ? brakeman_result["warnings"].length : 0
-        bundler_audit_vulnerability_count = bundler_audit_result && bundler_audit_result["scan"] && bundler_audit_result["scan"]["results"] ? bundler_audit_result["scan"]["results"].select { |result| result["type"] == "unpatched_gem" }.length : 0
+        brakeman_warning_count = brakeman_result && brakeman_result['warnings'] ? brakeman_result['warnings'].length : 0
+        bundler_audit_vulnerability_count = if bundler_audit_result && bundler_audit_result['scan'] && bundler_audit_result['scan']['results']
+                                              bundler_audit_result['scan']['results'].select do |result|
+                                                result['type'] == 'unpatched_gem'
+                                              end.length
+                                            else
+                                              0
+                                            end
 
         summary_output = "--- Scan Summary ---\n".colorize(:bold)
         summary_output += "AI Analysis: #{ai_risk_count} issues".colorize(ai_risk_count > 0 ? :red : :green) + "\n"
@@ -129,4 +135,4 @@ module Omamori
       end
     end
   end
-end
+end

data/lib/omamori/report_generator/html_formatter.rb

@@ -8,7 +8,7 @@ module Omamori
       def initialize(output_path_prefix, template_path = nil)
         @output_path_prefix = output_path_prefix
         # Use provided template_path if not nil, otherwise use default
-        @template_path = template_path || File.join(__dir__, "report_template.erb")
+        @template_path = template_path || File.join(__dir__, 'report_template.erb')
         @template = ERB.new(File.read(@template_path))
       rescue Errno::ENOENT
         raise "HTML template file not found at #{@template_path}" # Raise error if template is not found
@@ -16,16 +16,16 @@ module Omamori
 
       def format(combined_results)
         # Prepare data for the template
-        @ai_risks = combined_results && combined_results["ai_security_risks"] ? combined_results["ai_security_risks"] : []
-        @static_results = combined_results && combined_results["static_analysis_results"] ? combined_results["static_analysis_results"] : {}
+        @ai_risks = combined_results && combined_results['ai_security_risks'] ? combined_results['ai_security_risks'] : []
+        @static_results = combined_results && combined_results['static_analysis_results'] ? combined_results['static_analysis_results'] : {}
 
         # Render the template
         @template.result(binding)
       rescue Errno::ENOENT
-        "Error: HTML template file not found."
-      rescue => e
+        'Error: HTML template file not found.'
+      rescue StandardError => e
         "Error generating HTML report: #{e.message}"
       end
     end
   end
-end
+end

data/lib/omamori/report_generator/json_formatter.rb

@@ -16,4 +16,4 @@ module Omamori
       end
     end
   end
-end
+end

data/lib/omamori/setup_files.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require_relative 'ai_settings'
+
+module Omamori
+  # The files `omamori init` and `omamori ci-setup` write. Provider names are not listed here:
+  # whatever AISettings accepts (any RubyLLM provider, claude_code, codex) is written as given.
+  module SetupFiles
+    OMAMORIIGNORE = <<~IGNORE
+      # Omamori ignore file
+      # Add files and directories to ignore during Omamori scans.
+      # Lines starting with # are comments.
+      # Globs are supported (e.g., *.tmp, spec/fixtures/)
+      # Negation with ! (e.g., !important.log) - not fully implemented in current basic matcher
+
+      # Log files
+      log/
+      *.log
+
+      # Temporary files
+      tmp/
+      *.tmp
+      *.swp
+      *.swo
+
+      # OS-specific files
+      .DS_Store
+      Thumbs.db
+
+      # Vendor directory (often contains third-party code)
+      vendor/bundle/
+
+      # Coverage reports
+      coverage/
+
+      # Node.js dependencies
+      node_modules/
+
+      # Build artifacts
+      pkg/
+
+      # Test files and fixtures (optional, consider if they contain sensitive examples)
+      # spec/
+      # test/
+      # features/
+
+      # Database schema and migrations (usually not directly exploitable via code injection)
+      # db/schema.rb
+      # db/migrate/
+
+      # Assets (compiled or static, less likely to have Ruby vulnerabilities)
+      # app/assets/builds/
+      # public/assets/
+    IGNORE
+
+    # claude_code / codex use the CLI's login on the machine. omamori does not install or log in CLIs on
+    # CI runners: their packages and login methods are theirs to change.
+    CLI_IN_CI_NOTE = 'claude_code / codex need the CLI installed and logged in on the runner, which this ' \
+                     'configuration does not do. Set that up yourself, or use an API reporter in CI ' \
+                     '(add --reporter PROVIDER --reporter-model MODEL to the scan command).'
+
+    module_function
+
+    # settings: a resolved AISettings. language: e.g. "ja", or nil for the default (en)
+    def omamorirc(settings, language: nil)
+      <<~YAML
+        # .omamorirc
+        # Generated by `omamori init`. Check the setup with `omamori doctor`.
+
+        # Reporter: the LLM that writes reports. Any RubyLLM provider (with a model),
+        # or claude_code / codex to use a subscription CLI (claude -p / codex exec).
+        #{role_yaml('reporter', settings.reporter.merge(fallback_hash(settings)))}
+          # concurrency: 8           # Reports written in parallel (default 3 for CLIs, 8 for APIs)
+
+        # Classifier (optional): a fast decision model that checks each risk as a yes/no question.
+        # Only the flagged checks are sent to the reporter. Without it, the reporter checks everything.
+        #{classifier_yaml(settings)}
+
+        #{api_key_comment(settings)}
+
+        # Language of the report details (default: en)
+        #{language ? "language: #{language}" : '# language: ja'}
+
+        # Security checks to run (optional; default: the 8 main checks without a classifier, all 35 with one)
+        # checks:
+        #   - xss
+        #   - csrf
+        #   - idor
+
+        # Report output settings (optional)
+        # report:
+        #   output_path: ./omamori_report            # Prefix for html/json reports
+        #   html_template: custom_report_template.erb
+
+        # Static analyser options (optional)
+        # static_analysers:
+        #   brakeman:
+        #     options: "--force"
+        #   bundler_audit:
+        #     options: "--quiet"
+
+        # Chunk size for splitting large code content (optional, default: 8000 characters)
+        # chunk_size: 10000
+
+        # CI setup file paths (optional)
+        # ci_setup:
+        #   github_actions_path: .github/workflows/omamori_scan.yml
+        #   gitlab_ci_path: .gitlab-ci.yml
+      YAML
+    end
+
+    # What the user has to do outside omamori before scanning: one line per role
+    def credential_steps(settings)
+      roles(settings).map do |role, role_settings|
+        provider = role_settings['provider']
+        case provider
+        when 'claude_code' then "#{role}: install Claude Code and log in (`claude`), or set ANTHROPIC_API_KEY"
+        when 'codex' then "#{role}: install the Codex CLI and log in (`codex login`)"
+        else
+          env = AISettings.api_key_env(provider)
+          env ? "#{role}: set #{env}" : "#{role}: set what RubyLLM needs for #{provider} (https://rubyllm.com)"
+        end
+      end
+    end
+
+    def github_actions(settings)
+      <<~YAML
+        # .github/workflows/omamori_scan.yml
+        name: Omamori Security Scan
+
+        on:
+          push:
+            branches: [ main, master ]
+          pull_request:
+            branches: [ main, master ]
+
+        jobs:
+          security_scan:
+            runs-on: ubuntu-latest
+
+            steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+              with:
+                fetch-depth: 0 # Needed to diff against the base branch
+
+            - name: Set up Ruby
+              uses: ruby/setup-ruby@v1 # Reads .ruby-version
+              with:
+                bundler-cache: true
+        #{cli_note(settings, '    ')}
+            - name: Run Omamori Scan
+              env:
+        #{env_lines(settings, indent: '        ') { |name| "        #{name}: ${{ secrets.#{name} }}" }}
+              run: |
+                if [ "$GITHUB_EVENT_NAME" == "pull_request" ]; then
+                  bundle exec omamori scan --base "origin/$GITHUB_BASE_REF" --format console
+                else
+                  bundle exec omamori scan --all --format console
+                fi
+      YAML
+    end
+
+    def gitlab_ci(settings)
+      <<~YAML
+        # .gitlab-ci.yml
+        stages:
+          - security_scan
+
+        omamori_security_scan:
+          stage: security_scan
+          image: ruby:3.3 # Use your project's Ruby version
+          cache:
+            key:
+              files:
+                - Gemfile.lock
+            paths:
+              - vendor/bundle
+          before_script:
+            - bundle config set --local path vendor/bundle
+            - bundle install --jobs $(nproc) --retry 3
+        #{cli_note(settings, '  ')}
+          script:
+            - |
+              if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then
+                bundle exec omamori scan --base "origin/$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" --format console
+              else
+                bundle exec omamori scan --all --format console
+              fi
+          # Set these as masked CI/CD variables in GitLab:
+        #{env_lines(settings, indent: '  ') { |name| "  # #{name}" }}
+          variables:
+            GIT_DEPTH: "0" # Needed to diff against the target branch
+          rules:
+            - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
+            - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+      YAML
+    end
+
+    # [[role name, settings], ...] for the classifier, reporter and fallback reporter in use
+    def roles(settings)
+      [['classifier', settings.classifier], ['reporter', settings.reporter],
+       ['reporter.fallback', settings.reporter_fallback]].select { |_, role_settings| role_settings }
+    end
+
+    def role_yaml(name, role_settings)
+      lines = ["#{name}:"]
+      role_settings.each do |key, value|
+        if value.is_a?(Hash)
+          lines << "  #{key}:"
+          value.each { |sub_key, sub_value| lines << "    #{sub_key}: #{sub_value}" }
+        else
+          lines << "  #{key}: #{value}"
+        end
+      end
+      lines.join("\n")
+    end
+
+    def classifier_yaml(settings)
+      threshold = "  # threshold: #{AISettings::DEFAULT_THRESHOLD}            # Checks at or above this probability go to the reporter"
+      return "#{role_yaml('classifier', settings.classifier)}\n#{threshold}" if settings.classifier?
+
+      "# classifier:\n#   provider: typesafe        # typesafe / openai / ollama\n#   model: jev-1.13.0\n##{threshold[1..]}"
+    end
+
+    def fallback_hash(settings)
+      settings.reporter_fallback ? { 'fallback' => settings.reporter_fallback } : {}
+    end
+
+    def api_key_comment(settings)
+      names = roles(settings).filter_map { |_, role_settings| AISettings.api_key_env(role_settings['provider']) }.uniq
+      return '# API keys are read from environment variables (PROVIDER_API_KEY, e.g. ANTHROPIC_API_KEY).' if names.empty?
+
+      "# API keys are read from environment variables: #{names.join(', ')}"
+    end
+
+    def cli_providers(settings)
+      roles(settings).map { |_, role_settings| role_settings['provider'] } & AISettings::CLI_REPORTERS
+    end
+
+    # API key environment variables the scan step needs
+    def secret_names(settings)
+      roles(settings).filter_map { |_, role_settings| AISettings.api_key_env(role_settings['provider']) }.uniq
+    end
+
+    def env_lines(settings, indent:, &format)
+      names = secret_names(settings)
+      return "#{indent}# Add the environment variables RubyLLM needs for your provider" if names.empty?
+
+      names.map(&format).join("\n")
+    end
+
+    # A comment in the CI file when a role uses a subscription CLI
+    def cli_note(settings, indent)
+      return '' if cli_providers(settings).empty?
+
+      "#{indent}# #{CLI_IN_CI_NOTE}"
+    end
+  end
+end

data/lib/omamori/static_analysers/brakeman_runner.rb

@@ -8,7 +8,7 @@ module Omamori
       end
 
       def run
-        puts "Running Brakeman..."
+        puts 'Running Brakeman...'
         # Determine Brakeman command based on options
         # Use --force to run scan even if it's not a Rails application
         # Use -f json for JSON output
@@ -18,11 +18,11 @@ module Omamori
           if value.is_a?(TrueClass)
             key.to_s
           elsif value.is_a?(FalseClass)
-            "" # Don't include false flags
+            '' # Don't include false flags
           else
             "#{key} #{value}"
           end
-        end.join(" ").strip
+        end.join(' ').strip
 
         brakeman_command = "brakeman -f json . --force #{options_string}".strip # strip again in case options_string is empty
 
@@ -35,17 +35,17 @@ module Omamori
           # the test setup might be causing it to be called multiple times or the mock is misconfigured.
           JSON.parse(brakeman_output)
         rescue Errno::ENOENT
-          puts "Error: Brakeman command not found. Is Brakeman installed?"
+          puts 'Error: Brakeman command not found. Is Brakeman installed?'
           nil
         rescue JSON::ParserError
-          puts "Error: Failed to parse Brakeman JSON output."
+          puts 'Error: Failed to parse Brakeman JSON output.'
           puts "Raw output:\n#{brakeman_output}"
           nil
-        rescue => e
+        rescue StandardError => e
           puts "An error occurred during Brakeman execution: #{e.message}"
           nil
         end
       end
     end
   end
-end
+end

data/lib/omamori/static_analysers/bundler_audit_runner.rb

@@ -14,7 +14,9 @@ module Omamori
         # Example: bundle audit --format json
         # Include options passed during initialization
         # Build options string from the options hash
-        options_string = @options.map { |key, value| "--#{key.to_s.gsub('_', '-')}" + (value == true ? "" : " #{value}") }.join(" ")
+        options_string = @options.map do |key, value|
+          "--#{key.to_s.gsub('_', '-')}" + (value == true ? '' : " #{value}")
+        end.join(' ')
         bundler_audit_command = "bundle audit --format json#{options_string.empty? ? '' : " #{options_string}"}"
 
         begin
@@ -32,22 +34,22 @@ module Omamori
             # Return the entire parsed output hash
             parsed_output
           else
-            puts "Error: Unexpected Bundler-Audit JSON output structure."
+            puts 'Error: Unexpected Bundler-Audit JSON output structure.'
             puts "Raw output:\n#{bundler_audit_output}"
             nil # Return nil if the structure is unexpected
           end
         rescue Errno::ENOENT
-          puts "Error: bundle command not found. Is Bundler installed?"
+          puts 'Error: bundle command not found. Is Bundler installed?'
           nil
         rescue JSON::ParserError
-          puts "Error: Failed to parse Bundler-Audit JSON output."
+          puts 'Error: Failed to parse Bundler-Audit JSON output.'
           puts "Raw output:\n#{bundler_audit_output}"
           nil
-        rescue => e
+        rescue StandardError => e
           puts "An error occurred during Bundler-Audit execution: #{e.message}"
           nil
         end
       end
     end
   end
-end
+end

data/lib/omamori/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omamori
-  VERSION = "0.1.2"
-end
+  VERSION = '0.2.0'
+end