sharekit-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0cde6c59b8fa8f0a9b7405d8f67ccba50390a1cfeb03a10628f39cfc7b1c823c
+  data.tar.gz: 9d86a7780e71640e1597d57912113a9c154256eb799aa2e28e7408686dbb2844
+SHA512:
+  metadata.gz: 7bea1ae6dc74aab3e5a3a57d45e4c9ad986b046485f26020a2bbafbb1cb626250e30a748490b671cd6be9c78be62d729cdade72df9e6afcacb04496ca24bf8c5
+  data.tar.gz: 8a02b6895b8318687478166602ec1341cc537b2d44e4b3351ab6771807c2df9679a07b380d99557c11caf50f9a9267221716e1db0823c6111e951df1f064585b

data/.ruby-version

@@ -0,0 +1 @@
+3.4.10

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-07-25
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Lucas Santana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# sharekit-cli
+
+A small CLI that scaffolds a publishable "AI coding setup" profile and scans a directory for
+leaked secrets — private keys, cloud/API tokens, sensitive env vars — blocking on high-severity
+findings unless you pass `--force`.
+
+It's a Ruby port of the `init` and `scan` commands from
+[sharekit](https://github.com/LucasSantana-Dev/sharekit), a TypeScript CLI I built and publish
+to npm. This port is deliberately not a line-for-line translation — it's rebuilt around Ruby
+idioms that don't have a clean TS equivalent:
+
+- **`Data.define`** for the immutable `Finding` value object, with `Comparable` mixed in for
+  free severity-ranked sorting, and free `Hash` deconstruction for pattern matching.
+- **A rule table, not an if/elsif chain.** Each secret pattern is a `Scanner::Rule` (a `Data`
+  object: pattern + severity + preview metadata), stored in a frozen array. Adding a rule means
+  appending to `RULES` — the scan loop itself never changes.
+- **`Enumerator` dual API.** `Scanner.scan` yields to a block when one is given, or returns an
+  `Enumerator` when it isn't (`return to_enum(:scan, ...) unless block_given?`) — the same
+  pattern as `Array#each`. Callers can stream (`each { }`) or collect (`.to_a`, `.first`, `.lazy`)
+  without the scanner caring which.
+- **`case/in` pattern matching** in `Reporter.format_line`, matching directly on the `Finding`'s
+  deconstructed fields instead of manual attribute access.
+- **Thor** for CLI dispatch instead of hand-parsed `ARGV`/flags.
+- **`git ls-files`, not a hand-rolled ignore-file parser.** `scan` defers to git for
+  `.gitignore`-aware file listing when run inside a repo (via `Open3`, argv-array — no shell
+  interpolation), instead of reimplementing gitignore match semantics.
+
+## Install
+
+Not yet published to RubyGems. Install straight from git:
+
+```bash
+gem install specific_install
+gem specific_install https://github.com/LucasSantana-Dev/sharekit-cli.git
+```
+
+Or add to a `Gemfile`:
+
+```ruby
+gem "sharekit-cli", git: "https://github.com/LucasSantana-Dev/sharekit-cli.git"
+```
+
+## Usage
+
+```bash
+sharekit-cli scan [DIR]          # scan a directory (default: .)
+sharekit-cli scan [DIR] --force  # don't block on high-severity findings
+
+sharekit-cli init [SKILL...]              # scaffold ./sharekit-profile
+sharekit-cli init --dir PATH [SKILL...]   # scaffold at a custom path
+sharekit-cli init --force                 # overwrite an existing dir; override secret blocking
+```
+
+```
+$ sharekit-cli scan .
+
+  ⚠  Secret patterns detected:
+    .env:1 [AWS Access Key ID] …Y=AKIAEXAMPLEKEY000000
+
+  ⚠  Review and redact secrets before pushing to a public repository.
+
+Secrets export blocked: 1 high-severity finding(s) detected. Review and remove secrets, or re-run with --force to override.
+```
+
+Both commands exit `1` when a high-severity secret is found and `--force` wasn't passed; `0`
+otherwise. `init` copies `~/.claude/CLAUDE.md` and `~/.cursor/.cursorrules` into the new profile
+(or writes placeholders if they don't exist) and scans everything it copies for secrets before
+reporting success.
+
+### Rules
+
+| Rule                          | Severity |
+|--------------------------------|----------|
+| Private Key Block              | high     |
+| AWS Access Key ID              | high     |
+| GitHub Personal Access Token   | high     |
+| Slack Token                    | high     |
+| Google API Key                 | high     |
+| Bearer Token (JWT)             | high     |
+| Home Directory Path Leak       | low      |
+| Env Var: Sensitive Key         | medium   |
+
+## Development
+
+```bash
+bin/setup                            # install dependencies
+bundle exec rspec                    # run the test suite (61 examples)
+bundle exec rubocop                  # lint
+bundle exec bundler-audit check --update  # dependency vulnerability scan
+bin/console                          # interactive prompt
+```
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/sharekit-cli

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "sharekit/cli"
+
+Sharekit::Cli::App.start(ARGV)

data/lib/sharekit/cli/file_lister.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Sharekit
+  module Cli
+    # Picks which files a scan should look at. Inside a git repo, defers to
+    # `git ls-files` (tracked + untracked-but-not-ignored) so .gitignore is
+    # respected for free instead of reimplementing its match semantics.
+    # Outside a git repo, falls back to a plain glob with noise directories
+    # excluded.
+    module FileLister
+      DEFAULT_EXCLUDED_DIRS = %w[.git node_modules vendor .bundle].freeze
+
+      module_function
+
+      def list(dir)
+        git_tracked_files(dir) || glob_files(dir)
+      end
+
+      # Returns nil (not an empty array) when +dir+ isn't inside a git repo or
+      # git isn't installed, so the caller falls back to glob_files instead of
+      # silently scanning nothing.
+      def git_tracked_files(dir)
+        out, status = Open3.capture2("git", "-C", dir, "ls-files", "--cached", "--others", "--exclude-standard")
+        return nil unless status.success?
+
+        out.lines.map { |line| File.join(dir, line.chomp) }
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def glob_files(dir)
+        Dir.glob("#{dir}/**/*").select { |path| File.file?(path) && !excluded?(path) }
+      end
+
+      def excluded?(path)
+        DEFAULT_EXCLUDED_DIRS.any? { |dir_name| path.split(File::SEPARATOR).include?(dir_name) }
+      end
+    end
+  end
+end

data/lib/sharekit/cli/finding.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sharekit
+  module Cli
+    SEVERITY_RANK = { high: 2, medium: 1, low: 0 }.freeze
+
+    # Immutable value object for one scan hit. Data.define gives us structural
+    # equality and Hash-pattern deconstruction (`in {severity:, rule:}`) for free —
+    # a plain TS interface has neither.
+    Finding = Data.define(:rule, :file, :line, :preview, :severity) do
+      include Comparable
+
+      def <=>(other)
+        SEVERITY_RANK.fetch(severity) <=> SEVERITY_RANK.fetch(other.severity)
+      end
+
+      def high? = severity == :high
+    end
+  end
+end

data/lib/sharekit/cli/init.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Sharekit
+  module Cli
+    # Scaffolds a publishable sharekit profile: sharekit.toml, a claude/
+    # CLAUDE.md, a cursor/.cursorrules, an empty shared/, and any requested
+    # skill directories — copied from the caller's own AI-tooling config, so
+    # the result becomes an install target for `sharekit install <user>`.
+    class Init
+      Result = Data.define(:profile_dir, :findings, :created)
+      SourceFile = Data.define(:source, :dest, :placeholder)
+
+      def self.call(profile_dir:, skill_names: [], source_root: ENV.fetch("HOME", Dir.pwd), force: false)
+        new(profile_dir:, skill_names:, source_root:, force:).call
+      end
+
+      def initialize(profile_dir:, skill_names:, source_root:, force:)
+        @profile_dir = profile_dir
+        @skill_names = skill_names
+        @source_root = source_root
+        @force = force
+        @findings = []
+        @created = []
+      end
+
+      STANDARD_FILES = [
+        SourceFile.new(source: [".claude", "CLAUDE.md"], dest: %w[claude CLAUDE.md],
+                       placeholder: "# My AI coding instructions\n"),
+        SourceFile.new(source: [".cursor", ".cursorrules"], dest: %w[cursor .cursorrules],
+                       placeholder: "# Cursor IDE rules\n")
+      ].freeze
+
+      def call
+        prepare_profile_dir
+        write_manifest
+        STANDARD_FILES.each { |file| scaffold(file) }
+        scaffold_shared
+        @skill_names.each { |name| scaffold_skill(name) }
+
+        Result.new(profile_dir: @profile_dir, findings: @findings, created: @created)
+      end
+
+      private
+
+      def prepare_profile_dir
+        if Dir.exist?(@profile_dir)
+          raise Error, "Profile directory already exists: #{@profile_dir}. Use --force to overwrite." unless @force
+
+          FileUtils.rm_rf(@profile_dir)
+        end
+        FileUtils.mkdir_p(@profile_dir)
+      end
+
+      def write_manifest
+        path = File.join(@profile_dir, "sharekit.toml")
+        File.write(path, <<~TOML)
+          [profile]
+          name = "#{ENV.fetch("USER", "unknown")}"
+          version = "0.1.0"
+          description = "My AI coding setup"
+        TOML
+        @created << path
+      end
+
+      def scaffold(file)
+        source = File.join(@source_root, *file.source)
+        dest = File.join(@profile_dir, *file.dest)
+        FileUtils.mkdir_p(File.dirname(dest))
+        if File.exist?(source)
+          FileUtils.cp(source, dest)
+          scan_and_record(dest)
+        else
+          File.write(dest, file.placeholder)
+        end
+        @created << dest
+      end
+
+      def scaffold_shared
+        dir = File.join(@profile_dir, "shared")
+        FileUtils.mkdir_p(dir)
+        FileUtils.touch(File.join(dir, ".gitkeep"))
+        @created << dir
+      end
+
+      def scaffold_skill(name)
+        source_dir = File.join(@source_root, ".claude", "skills", name)
+        unless Dir.exist?(source_dir)
+          puts "  ~ skill '#{name}' not found at #{source_dir}"
+          return
+        end
+
+        dest_base = File.join(@profile_dir, "claude", "skills", name)
+        Dir.glob("#{source_dir}/**/*").select { |f| File.file?(f) }.each do |source_file|
+          copy_skill_file(source_file, source_dir, dest_base)
+        end
+      end
+
+      def copy_skill_file(source_file, source_dir, dest_base)
+        dest_file = File.join(dest_base, source_file.delete_prefix("#{source_dir}/"))
+        FileUtils.mkdir_p(File.dirname(dest_file))
+        FileUtils.cp(source_file, dest_file)
+        scan_and_record(dest_file)
+        @created << dest_file
+      end
+
+      def scan_and_record(path)
+        content = File.read(path, encoding: "UTF-8")
+        @findings.concat(Scanner.scan(content, file: path).to_a)
+      end
+    end
+  end
+end

data/lib/sharekit/cli/reporter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Sharekit
+  module Cli
+    # Formats findings for terminal output and gates high-severity secrets.
+    module Reporter
+      GREEN = "\e[32m"
+      YELLOW = "\e[33m"
+      RESET = "\e[0m"
+
+      module_function
+
+      def report(findings, force: false)
+        if findings.empty?
+          puts "#{GREEN}  ✓ No secrets detected.\n#{RESET}"
+          return
+        end
+
+        puts "#{YELLOW}\n  ⚠  Secret patterns detected:#{RESET}"
+        findings.each { |finding| puts "#{YELLOW}    #{format_line(finding)}#{RESET}" }
+        puts "#{YELLOW}\n  ⚠  Review and redact secrets before pushing to a public repository.\n#{RESET}"
+
+        gate!(findings, force:)
+      end
+
+      # Data.define objects deconstruct into a Hash for free, so `in` can match
+      # directly on the fields we care about — no case/when + manual field access.
+      def format_line(finding)
+        case finding
+        in { file:, line:, rule:, preview: }
+          "#{file}:#{line} [#{rule}] #{preview}"
+        end
+      end
+
+      def gate!(findings, force:)
+        high = findings.select(&:high?)
+        return if high.empty? || force
+
+        raise Error, "Secrets export blocked: #{high.size} high-severity finding(s) detected. " \
+                      "Review and remove secrets, or re-run with --force to override."
+      end
+    end
+  end
+end

data/lib/sharekit/cli/scanner.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "finding"
+
+module Sharekit
+  module Cli
+    # Rule-driven secret scanner. Each rule is data (pattern + metadata), not a
+    # branch in an if/elsif chain — adding a rule means appending to RULES,
+    # never touching the scan loop.
+    class Scanner
+      Rule = Data.define(:name, :pattern, :severity, :context_before, :max_len, :leading_ellipsis)
+
+      RULES = [
+        Rule.new(name: "Private Key Block",
+                 pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+                 severity: :high, context_before: 0, max_len: 40, leading_ellipsis: false),
+        Rule.new(name: "AWS Access Key ID",
+                 pattern: /AKIA[0-9A-Z]{16}/,
+                 severity: :high, context_before: 5, max_len: 20, leading_ellipsis: true),
+        Rule.new(name: "GitHub Personal Access Token",
+                 pattern: /ghp_[A-Za-z0-9_]{20,}/,
+                 severity: :high, context_before: 5, max_len: 40, leading_ellipsis: true),
+        Rule.new(name: "GitHub Personal Access Token",
+                 pattern: /github_pat_[A-Za-z0-9_]{20,}/,
+                 severity: :high, context_before: 5, max_len: 40, leading_ellipsis: true),
+        Rule.new(name: "Slack Token",
+                 pattern: /xox[baprs]-[A-Za-z0-9-]{10,}/,
+                 severity: :high, context_before: 5, max_len: 40, leading_ellipsis: true),
+        Rule.new(name: "Google API Key",
+                 pattern: /AIza[0-9A-Za-z\-_]{30,40}/,
+                 severity: :high, context_before: 5, max_len: 40, leading_ellipsis: true),
+        Rule.new(name: "Bearer Token",
+                 pattern: /Bearer eyJ[A-Za-z0-9._-]*\.[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+/,
+                 severity: :high, context_before: 0, max_len: 30, leading_ellipsis: false),
+        Rule.new(name: "Home Directory Path Leak",
+                 pattern: %r{(/Users/[a-zA-Z0-9_-]+|/home/[a-zA-Z0-9_-]+)},
+                 severity: :low, context_before: 5, max_len: 40, leading_ellipsis: true)
+      ].freeze
+
+      ENV_VAR_PATTERN = /(?:^|\s)(?:export\s+)?([A-Z_]+?)=(.*)$/
+      SENSITIVE_KEY_PATTERN = /(SECRET|TOKEN|PASSWORD|API_KEY|APIKEY|ACCESS_KEY)/i
+      PLACEHOLDER_PREFIXES = ['""', "''", "xxx", "<", "changeme", "your-", "your_"].freeze
+
+      class << self
+        # Scans +content+ line by line. Yields each Finding as it's found when
+        # a block is given; otherwise returns an Enumerator (same dual API as
+        # Array#each), so callers can stream (`each { }`) or collect (`.to_a`,
+        # `.first`, `.lazy`) without the scanner caring which.
+        def scan(content, file: nil)
+          return to_enum(:scan, content, file:) unless block_given?
+
+          content.each_line.with_index(1) do |raw_line, line_num|
+            line = raw_line.chomp
+            finding = rule_finding(line, file, line_num) || env_var_finding(line, file, line_num)
+            yield finding if finding
+          end
+        end
+
+        def truncate_preview(line, idx, context_before: 5, max_len: 40, leading_ellipsis: true)
+          start = [0, idx - context_before].max
+          finish = [line.length, idx + max_len].min
+          leading = leading_ellipsis && start.positive? ? "…" : ""
+          trailing = finish < line.length ? "…" : ""
+          "#{leading}#{line[start...finish]}#{trailing}"
+        end
+
+        private
+
+        def rule_finding(line, file, line_num)
+          rule = RULES.find { |r| r.pattern.match?(line) }
+          return unless rule
+
+          match = rule.pattern.match(line)
+          preview = truncate_preview(
+            line, match.begin(0),
+            context_before: rule.context_before, max_len: rule.max_len, leading_ellipsis: rule.leading_ellipsis
+          )
+          Finding.new(rule: rule.name, file:, line: line_num, preview:, severity: rule.severity)
+        end
+
+        def env_var_finding(line, file, line_num)
+          match = ENV_VAR_PATTERN.match(line)
+          return unless match
+
+          key_name = match[1].upcase
+          value = match[2]
+          return unless SENSITIVE_KEY_PATTERN.match?(key_name)
+          return if placeholder?(value)
+
+          Finding.new(rule: "Env Var: Sensitive Key", file:, line: line_num,
+                      preview: "#{key_name}=#{truncate_value(value)}", severity: :medium)
+        end
+
+        def placeholder?(value)
+          return true if value.empty? || value == '""' || value == "''"
+
+          PLACEHOLDER_PREFIXES.any? { |prefix| value.start_with?(prefix) }
+        end
+
+        def truncate_value(value)
+          value.length > 8 ? "#{value[0, 8]}…" : value
+        end
+      end
+    end
+  end
+end

data/lib/sharekit/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sharekit
+  module Cli
+    VERSION = "0.1.0"
+  end
+end

data/lib/sharekit/cli.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "cli/version"
+require_relative "cli/finding"
+require_relative "cli/scanner"
+require_relative "cli/reporter"
+require_relative "cli/file_lister"
+require_relative "cli/init"
+
+module Sharekit
+  module Cli
+    class Error < StandardError; end
+
+    # Thor gives us subcommand dispatch, flag parsing, and --help for free —
+    # the TS original hand-parses process.argv/flags itself.
+    class App < Thor
+      def self.exit_on_failure? = true
+
+      desc "scan [DIR]", "scan a directory for secret patterns"
+      method_option :force,
+                    type: :boolean,
+                    default: false,
+                    desc: "exit 0 even if high-severity findings detected"
+      def scan(dir = ".")
+        findings = FileLister.list(dir).flat_map do |path|
+          Scanner.scan(File.read(path, encoding: "UTF-8"), file: path).to_a
+        rescue ArgumentError, Errno::ENOENT, Errno::EACCES => e
+          puts "    ~ Skipped #{path}: #{e.class}"
+          []
+        end
+
+        Reporter.report(findings, force: options[:force])
+      rescue Error => e
+        warn e.message
+        exit 1
+      end
+
+      desc "init [SKILL...]", "scaffold a publishable sharekit profile"
+      method_option :force,
+                    type: :boolean,
+                    default: false,
+                    desc: "overwrite existing dir; override secret blocking"
+      method_option :dir,
+                    type: :string,
+                    default: "./sharekit-profile",
+                    desc: "profile directory to create"
+      def init(*skill_names)
+        result = Init.call(profile_dir: options[:dir], skill_names:, force: options[:force])
+        print_init_summary(result)
+        Reporter.report(result.findings, force: options[:force])
+      rescue Error => e
+        warn e.message
+        exit 1
+      end
+
+      no_commands do
+        def print_init_summary(result)
+          result.created.each { |path| puts "  + #{path}" }
+          puts "\n  ✓ Created profile at #{result.profile_dir}\n\n"
+        end
+      end
+    end
+  end
+end

data/sig/sharekit/cli.rbs

@@ -0,0 +1,6 @@
+module Sharekit
+  module Cli
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: sharekit-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lucas Santana
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: A small rule-driven CLI that scans files for private keys, cloud/API
+  tokens, and sensitive env vars, and blocks on high-severity findings unless --force
+  is given.
+email:
+- lucas.diassantana@gmail.com
+executables:
+- sharekit-cli
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/sharekit-cli
+- lib/sharekit/cli.rb
+- lib/sharekit/cli/file_lister.rb
+- lib/sharekit/cli/finding.rb
+- lib/sharekit/cli/init.rb
+- lib/sharekit/cli/reporter.rb
+- lib/sharekit/cli/scanner.rb
+- lib/sharekit/cli/version.rb
+- sig/sharekit/cli.rbs
+homepage: https://github.com/LucasSantana-Dev/sharekit-cli
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/LucasSantana-Dev/sharekit-cli
+  source_code_uri: https://github.com/LucasSantana-Dev/sharekit-cli/tree/main
+  changelog_uri: https://github.com/LucasSantana-Dev/sharekit-cli/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Scan a directory for leaked secrets before you publish it.
+test_files: []