snoot 0.1.0

data/snoot.allium

@@ -0,0 +1,482 @@
+-- allium: 3
+-- snoot.allium
+
+-- Scope: Runtime behaviour of a Ruby gem that runs reek, flog and flay over a
+--        configured path set and emits a single agent-targeted report
+--        describing one finding.
+-- Includes: invocation, finding collection, finding selection, report emission,
+--           run outcomes (FindingRendered, NothingToReport, AnalysisFailed).
+-- Excludes:
+--   - Build-time vendored-doc workflow (sync, packaging, version pinning)
+--   - Gem packaging, dependency management, CLI argument parsing internals
+--   - CI gating policy (operator decisions about which exit codes
+--     fail builds, retry behaviour, etc.) -- exit-code semantics
+--     themselves are in scope, see CLI surface
+--   - Diff-aware analysis, JSON output, MCP, pre-commit hooks (non-goals
+--     enumerated in the design doc)
+-- Centred on: the LLM agent reading the emitted report.
+
+------------------------------------------------------------
+-- External Entities
+------------------------------------------------------------
+
+-- The three analysers the gem orchestrates. Their internal behaviour is out
+-- of scope; their findings are surfaced via black-box analyse_* functions.
+
+external entity Reek {
+    -- Reek detects code smells in Ruby source. A run yields zero or more Smell
+    -- value instances, each tagged with a SmellType.
+}
+
+external entity Flog {
+    -- Flog assigns a complexity score to methods and classes. A run yields
+    -- zero or more ComplexityHit instances.
+}
+
+external entity Flay {
+    -- Flay detects structural duplication across the analysed source. A run
+    -- yields zero or more DuplicationCluster instances.
+}
+
+------------------------------------------------------------
+-- Value Types
+------------------------------------------------------------
+
+value Path {
+    raw: String
+}
+
+value Location {
+    path: Path
+    line_start: Integer
+    line_end: Integer
+}
+
+-- A reek smell type identifier (e.g. "FeatureEnvy", "TooManyMethods"). The
+-- set of valid values is owned by reek.
+value SmellType {
+    name: String
+}
+
+------------------------------------------------------------
+-- Analyser Result
+------------------------------------------------------------
+
+-- The two-shaped outcome of AnalyserOrchestration#analyse. AnalyserResult is
+-- a sum-type entity so the rule body can narrow on `kind`. Both variants
+-- are short-lived: an instance is created by analyse() and consumed within
+-- a single AnalyseRun execution; neither persists beyond the rule.
+entity AnalyserResult {
+    kind: Sources | AnalyserFailure
+}
+
+-- The bundle of analyser outputs produced by a successful invocation of
+-- AnalyserOrchestration#analyse. Carries the per-analyser finding sets
+-- so AnalyseRun can derive significance and candidate views without
+-- re-invoking the analysers.
+variant Sources : AnalyserResult {
+    smells: Set<Smell>
+    complexities: Set<ComplexityHit>
+    duplications: Set<DuplicationCluster>
+}
+
+-- An analyser failure surfaced to the operator on outcome = analysis_failed.
+-- The analyser field identifies which of the three analysers (Reek, Flog,
+-- Flay) produced the failure; message is the human-readable error detail
+-- carried on stderr. Only the first failed analyser in canonical order
+-- (Reek -> Flog -> Flay) is recorded; the orchestration aborts on first
+-- failure and does not invoke subsequent analysers.
+variant AnalyserFailure : AnalyserResult {
+    analyser: Reek | Flog | Flay
+    message: String
+}
+
+------------------------------------------------------------
+-- Contracts
+------------------------------------------------------------
+
+-- The analyser-orchestration contract is the gem's integration shape with
+-- the three external analysers and the vendored-docs corpus. The CLI
+-- surface demands this contract: an implementation must supply each
+-- signature for the spec's rules to be satisfiable. The contract names the
+-- analyser entities (Reek, Flog, Flay) explicitly so the spec records that
+-- it depends on those tools, even though their internal behaviour is out
+-- of scope.
+contract AnalyserOrchestration {
+    -- adapter_label maps an external analyser to its short identifier
+    -- (e.g. "reek", "flog", "flay"). The signature exists to record the
+    -- per-tool dependency on Reek, Flog and Flay at the contract
+    -- boundary; rule bodies do not invoke it.
+    adapter_label: (analyser: Reek | Flog | Flay) -> String
+
+    -- vendored_doc maps a smell type to its bundled markdown doc, or null
+    -- when no doc is bundled for that smell type. Consulted both to filter
+    -- the smell candidate pool and to render the doc section. Location
+    -- rendering for the FindingContext section is carried by Location
+    -- itself, not the orchestration contract.
+    vendored_doc: (smell_type: SmellType) -> String?
+
+    -- Significance pre-filters. Each returns the subset of its input deemed
+    -- significant enough to warrant attention from the agent reading the
+    -- report. Numeric
+    -- thresholds are an implementation policy each adapter owns; the
+    -- contract requires only that the result is a subset of the input and
+    -- is deterministic per @invariant Determinism. This is the gate that
+    -- filters findings that don't warrant addressing before category
+    -- selection in AnalyseRun.
+    significant_smells: (smells: Set<Smell>) -> Set<Smell>
+    significant_complexities: (complexities: Set<ComplexityHit>) -> Set<ComplexityHit>
+    significant_duplications: (duplications: Set<DuplicationCluster>) -> Set<DuplicationCluster>
+
+    -- analyse runs the three analysers in canonical order (Reek -> Flog
+    -- -> Flay), capturing each output as it succeeds. On the first
+    -- failure it returns an AnalyserFailure tagged with that analyser
+    -- and does not invoke the remaining ones; on full success it
+    -- returns a Sources bundling the three result sets. This signature
+    -- respects @invariant Determinism: for the same path set, the same
+    -- outcome (including which analyser fails first, if any, and its
+    -- message) is produced within a single CLI invocation.
+    analyse: (paths: Set<Path>) -> AnalyserResult
+
+    @invariant Determinism
+        -- Each signature is pure within a single CLI invocation: the same
+        -- inputs produce the same outputs. Outputs may differ between
+        -- invocations as the source under analysis changes; that is not a
+        -- violation of determinism within a run.
+}
+
+------------------------------------------------------------
+-- Entities and Variants
+------------------------------------------------------------
+
+-- A Finding is the unit a Run can render. It is one of three variants,
+-- corresponding to the three analysers the gem orchestrates. Findings exist
+-- only within the scope of the Run that produced them; they have no
+-- persistence beyond the run.
+
+entity Finding {
+    kind: Smell | ComplexityHit | DuplicationCluster
+}
+
+variant Smell : Finding {
+    smell_type: SmellType
+    location: Location
+    message: String
+}
+
+variant ComplexityHit : Finding {
+    location: Location
+    method_name: String?
+    score: Decimal
+}
+
+variant DuplicationCluster : Finding {
+    signature: String
+    locations: Set<Location>
+}
+
+-- A Run represents one CLI invocation. Its lifecycle terminates in exactly
+-- one of three outcomes.
+
+entity Run {
+    paths: Set<Path>
+    outcome: pending | finding_rendered | nothing_to_report | analysis_failed
+
+    selected_finding: Finding when outcome = finding_rendered
+
+    -- The analyser failure detail surfaced when the run aborts. Present
+    -- only on outcome = analysis_failed; carries the first analyser to fail
+    -- in canonical order (Reek -> Flog -> Flay) and its error message.
+    failure: AnalyserFailure when outcome = analysis_failed
+
+    transitions outcome {
+        pending -> finding_rendered
+        pending -> nothing_to_report
+        pending -> analysis_failed
+        terminal: finding_rendered, nothing_to_report, analysis_failed
+    }
+}
+
+------------------------------------------------------------
+-- Rules
+------------------------------------------------------------
+
+-- The pipeline is two rules. AnalyseRun spans collection through selection
+-- (it produces the terminal outcome). RenderReport reacts to a selected
+-- finding by emitting the report.
+
+rule AnalyseRun {
+    when: RunInvoked(paths)
+
+    ensures:
+        let run = Run.created(paths: paths, outcome: pending)
+
+        -- analyse runs the three analysers in canonical order (Reek ->
+        -- Flog -> Flay) and returns either the captured Sources bundle
+        -- or, on the first analyser error, an AnalyserFailure. A
+        -- single invocation produces both the failure-detection result
+        -- and the per-analyser outputs, so the analysers are not
+        -- re-invoked along the success branch.
+        let result = analyse(run.paths)
+
+        if result.kind = AnalyserFailure:
+            run.outcome = analysis_failed
+            run.failure = result
+        else if result.kind = Sources:
+            -- Significance is the "warrants addressing" pre-filter: each
+            -- analyser adapter discards its own noise (per-analyser
+            -- numeric thresholds are the implementation's concern) before
+            -- category selection runs. The doc-less filter for smells
+            -- sits on top of significance, so only significant doc-less
+            -- smells reach SkippedDocLessSmellWarned. Doc-less detection
+            -- only matters for smells -- non-smell findings have no
+            -- vendored doc concept -- and because select_top_finding's
+            -- category priority puts Smell strictly above the other
+            -- variants, the top smell among significant smells is
+            -- exactly the would-be-top-finding whenever it would have
+            -- been a smell. Hence top_smell_overall is computed over the
+            -- significant smell set rather than the cross-category union.
+            let significant_smell_findings = significant_smells(result.smells)
+            let significant_complexity_findings = significant_complexities(result.complexities)
+            let significant_duplication_findings = significant_duplications(result.duplications)
+
+            -- A reek smell is excluded from the candidate pool when no
+            -- vendored doc exists for its type. If the would-have-been-
+            -- selected finding (i.e. the top-scoring finding before this
+            -- filter) is one of these, a stderr warning is emitted (see
+            -- SkippedDocLessSmellWarned trigger below).
+            let documented_smell_findings =
+                filter(significant_smell_findings, s => vendored_doc(s.smell_type) != null)
+
+            let candidate_findings =
+                documented_smell_findings + significant_complexity_findings + significant_duplication_findings
+
+            let top_smell_overall = top_smell(significant_smell_findings)
+
+            -- select_top_finding orders findings by category priority
+            -- first, then by an analyser-natural primary key, then by
+            -- deterministic secondary keys to break ties. Category
+            -- priority: Smell > DuplicationCluster > ComplexityHit.
+            -- Within a category the primary key is the analyser's
+            -- natural ranking (smell-type instance count for Smells;
+            -- locations.size for DuplicationClusters; score for
+            -- ComplexityHits). Ties are broken by:
+            --   - Smell: smell_type.name ascending, then path ascending,
+            --     then line_start ascending.
+            --   - DuplicationCluster: signature ascending, then
+            --     min(location.path) ascending, then
+            --     min(location.line_start) ascending.
+            --   - ComplexityHit: path ascending, then line_start
+            --     ascending.
+            let selected = select_top_finding(candidate_findings)
+
+            if candidate_findings.count = 0:
+                run.outcome = nothing_to_report
+            else:
+                run.outcome = finding_rendered
+                run.selected_finding = selected
+
+            -- Stderr warning fires when the top significant smell has
+            -- no vendored doc. top_smell_overall is already Smell-or-
+            -- null, so a single null-check plus the doc check is enough
+            -- to gate the trigger; no variant narrowing is needed.
+            if top_smell_overall != null:
+                if vendored_doc(top_smell_overall.smell_type) = null:
+                    SkippedDocLessSmellWarned(
+                        run: run,
+                        smell_type: top_smell_overall.smell_type
+                    )
+}
+
+rule RenderReport {
+    when: run: Run.outcome becomes finding_rendered
+    requires: run.selected_finding != null
+
+    -- Section composition is variant-conditional:
+    --
+    -- For Smell findings the report is two sections:
+    --   - doc:       vendored_doc(smell_type) (always non-null here, per the
+    --                SelectedFindingsAreRenderable invariant)
+    --   - instances: every Smell from the analysed sources whose smell_type
+    --                matches the selected_finding's smell_type, grouped by
+    --                file, with files ordered by descending instance count
+    --                and alphabetical tie-break. The header / finding_context
+    --                sections are absent because the doc + instances pair
+    --                is sufficient context for an agent acting on a
+    --                multi-instance smell type.
+    --
+    -- For ComplexityHit and DuplicationCluster findings the report is the
+    -- three-section structure (header, finding_context, doc):
+    --   - ComplexityHit:      hand-written generic prose for high complexity
+    --   - DuplicationCluster: hand-written generic prose for high duplication
+    -- The exact prose is static implementation policy of the gem (one
+    -- string per non-Smell variant), not an orchestration-contract
+    -- responsibility. This mirrors the threshold-policy delegation in
+    -- AnalyserOrchestration: behavioural variability is contracted, but
+    -- static report copy is owned by the implementation.
+    ensures:
+        if run.selected_finding.kind = Smell:
+            ReportEmitted(
+                run: run,
+                finding: run.selected_finding,
+                sections: { doc, instances }
+            )
+        else:
+            ReportEmitted(
+                run: run,
+                finding: run.selected_finding,
+                sections: { header, finding_context, doc }
+            )
+
+    @guarantee SmellReportShape
+        -- For Smell findings, a rendered report contains, in order:
+        --   1. Doc       -- the vendored markdown for the selected smell type
+        --   2. Instances -- '## Instances' heading followed by per-file
+        --                  groupings of every Smell from the analysed sources
+        --                  matching the selected smell_type. Each file group
+        --                  is the raw path on its own line, then 2-space-
+        --                  indented 'Line N: <message>' lines. File groups
+        --                  are ordered by descending instance count, with
+        --                  alphabetical path as the tie-break.
+
+    @guarantee NonSmellReportShape
+        -- For ComplexityHit and DuplicationCluster findings, a rendered
+        -- report contains, in order:
+        --   1. Header         -- one-line summary (analyser-implicit, finding
+        --                        name, location)
+        --   2. FindingContext -- file path(s), line range(s), the analyser's
+        --                        message; for DuplicationCluster, all cluster
+        --                        locations are enumerated
+        --   3. Doc            -- one inlined hand-written prose constant
+
+    @guarantee AnalyserProvenanceImplicit
+        -- The report does not label the originating analyser. The shape of
+        -- the report (doc + instances for Smell vs header + finding_context
+        -- + doc for non-Smell) and the finding's wording (smell name vs
+        -- complexity language vs duplication enumeration) are sufficient
+        -- for the agent to infer provenance.
+
+    @guidance
+        -- Section ordering within each variant shape is structural.
+        -- Implementations should emit sections in the declared order so an
+        -- agent / parser can rely on predictable landmarks. The agent
+        -- reading the report should treat the inlined doc as primary
+        -- context for acting on the finding. For Smell findings, the
+        -- Instances list enumerates every site the agent must consider.
+        -- For non-Smell findings, the header and finding_context sections
+        -- locate the single finding so the agent can read the doc against
+        -- it.
+}
+
+------------------------------------------------------------
+-- Invariants
+------------------------------------------------------------
+
+-- A rendered run references exactly one finding. There is no concept of a
+-- top-tier of multiple findings in this spec.
+invariant SingleFindingPerRun {
+    for r in Runs:
+        r.outcome = finding_rendered implies r.selected_finding != null
+}
+
+-- A failed run carries a failure record describing which analyser aborted
+-- and the message it produced. The structural `when outcome = analysis_failed`
+-- obligation already pins the field's presence; this invariant makes the
+-- guarantee explicit so consumers can rely on r.failure being non-null
+-- whenever they observe r.outcome = analysis_failed.
+invariant FailurePresentOnFailedRuns {
+    for r in Runs:
+        r.outcome = analysis_failed implies r.failure != null
+}
+
+-- The selection filter excludes doc-less smells. Therefore: when a run's
+-- selected_finding is a Smell, that smell type has a vendored doc
+-- available. The quantification ranges over Smell instances directly so
+-- variant-specific access (smell_type) is unambiguous; the equality with
+-- selected_finding pins the relationship.
+invariant SelectedFindingsAreRenderable {
+    for r in Runs:
+        for s in Smells:
+            (r.outcome = finding_rendered and r.selected_finding = s)
+                implies vendored_doc(s.smell_type) != null
+}
+
+-- The selected finding must be significant: it must survive the
+-- significance pre-filter for its variant. This is the "warrants
+-- addressing" gate, complementary to SelectedFindingsAreRenderable's
+-- documented-doc gate. Quantification ranges over each variant; the
+-- implementation in AnalyserOrchestration owns the numeric thresholds.
+-- The membership test's input set differs by variant. The smell branch
+-- ranges over the smell set produced by analyse(r.paths) because an
+-- adapter may apply a collection-relative policy -- the production
+-- Default adapter filters by smell-type recurrence count, so a
+-- singleton {s} input would be incorrectly empty. Complexity and
+-- duplication adapters are per-instance (score floor and identity
+-- respectively), so the singleton {f} suffices for those.
+invariant SignificantFindingsOnly {
+    for r in Runs:
+        for s in Smells:
+            (r.outcome = finding_rendered and r.selected_finding = s)
+                implies s in significant_smells(analyse(r.paths).smells)
+        for c in ComplexityHits:
+            (r.outcome = finding_rendered and r.selected_finding = c)
+                implies c in significant_complexities({c})
+        for d in DuplicationClusters:
+            (r.outcome = finding_rendered and r.selected_finding = d)
+                implies d in significant_duplications({d})
+}
+
+------------------------------------------------------------
+-- Surfaces
+------------------------------------------------------------
+
+surface CLI {
+    -- The CLI's only domain input is the path set. Other flags (verbosity,
+    -- output destination) are out of scope at the spec level.
+    provides:
+        RunInvoked(paths)
+
+    contracts:
+        demands AnalyserOrchestration
+
+    @guarantee TerminatesInOneOutcome
+        -- Every accepted invocation produces exactly one of the three
+        -- terminal outcomes (FindingRendered, NothingToReport,
+        -- AnalysisFailed). Exit code by outcome:
+        --   nothing_to_report -> 0
+        --   finding_rendered  -> 1
+        --   analysis_failed   -> 2
+
+    @guarantee UsageErrorExit
+        -- An invocation whose argv shape the CLI rejects (unknown flag,
+        -- malformed switch) is not an accepted invocation: RunInvoked
+        -- does not fire, no Run is created, and TerminatesInOneOutcome
+        -- does not apply. The CLI exits 64 (POSIX EX_USAGE) and writes
+        -- the usage banner to stderr. Exit code 64 is reserved for this
+        -- pre-domain failure mode so an operator (or CI) can distinguish
+        -- a usage error from finding_rendered, both of which would
+        -- otherwise share an exit code.
+
+    @guarantee EmptyPathsDefault
+        -- An operator invocation that supplies no paths is treated as if
+        -- Path(".") had been supplied: the CLI surface normalises the
+        -- empty path set to {Path(".")} before RunInvoked fires.
+        -- RunInvoked is therefore always invoked with a non-empty path
+        -- set; downstream rules (including AnalyseRun) never observe an
+        -- empty paths argument.
+
+    @guarantee StdoutMutuallyExclusive
+        -- A run produces stdout content corresponding to its outcome:
+        --   finding_rendered  -> stdout = formatted report (variant-
+        --                        specific shape, see the RenderReport
+        --                        rule's @guarantee blocks)
+        --   nothing_to_report -> stdout = single-line acknowledgement
+        --                        (see the NothingToReport resolution at
+        --                        the bottom for the exact format)
+        --   analysis_failed   -> stdout = empty
+        -- Stderr carries warnings (missing vendored docs) at all outcomes.
+        -- On outcome = analysis_failed, stderr additionally carries the
+        -- failed analyser's message (run.failure.message): one analyser's
+        -- error, not aggregated across analysers and not multi-line per
+        -- analyser. These stderr contents are independent of stdout.
+}

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: snoot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Benjamin Kudria
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: flay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: flog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.9'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.5'
+description: |
+  snoot orchestrates reek, flog and flay over a configured path set
+  and emits a single agent-targeted report describing one finding.
+  Designed for an LLM coding agent as the reader.
+email:
+- ben@kudria.net
+executables:
+- snoot
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- data/reek_docs/API.md
+- data/reek_docs/Attribute.md
+- data/reek_docs/Basic-Smell-Options.md
+- data/reek_docs/Boolean-Parameter.md
+- data/reek_docs/Class-Variable.md
+- data/reek_docs/Code-Smells.md
+- data/reek_docs/Command-Line-Options.md
+- data/reek_docs/Control-Couple.md
+- data/reek_docs/Control-Parameter.md
+- data/reek_docs/Data-Clump.md
+- data/reek_docs/Duplicate-Method-Call.md
+- data/reek_docs/Feature-Envy.md
+- data/reek_docs/How-To-Write-New-Detectors.md
+- data/reek_docs/How-reek-works-internally.md
+- data/reek_docs/Instance-Variable-Assumption.md
+- data/reek_docs/Irresponsible-Module.md
+- data/reek_docs/LICENSE
+- data/reek_docs/Large-Class.md
+- data/reek_docs/Long-Parameter-List.md
+- data/reek_docs/Long-Yield-List.md
+- data/reek_docs/Manual-Dispatch.md
+- data/reek_docs/Missing-Safe-Method.md
+- data/reek_docs/Module-Initialize.md
+- data/reek_docs/Nested-Iterators.md
+- data/reek_docs/Nil-Check.md
+- data/reek_docs/RSpec-matchers.md
+- data/reek_docs/Rake-Task.md
+- data/reek_docs/Reek-4-to-Reek-5-migration.md
+- data/reek_docs/Reek-Driven-Development.md
+- data/reek_docs/Repeated-Conditional.md
+- data/reek_docs/Simulated-Polymorphism.md
+- data/reek_docs/Smell-Suppression.md
+- data/reek_docs/Style-Guide.md
+- data/reek_docs/Subclassed-From-Core-Class.md
+- data/reek_docs/Too-Many-Constants.md
+- data/reek_docs/Too-Many-Instance-Variables.md
+- data/reek_docs/Too-Many-Methods.md
+- data/reek_docs/Too-Many-Statements.md
+- data/reek_docs/Uncommunicative-Method-Name.md
+- data/reek_docs/Uncommunicative-Module-Name.md
+- data/reek_docs/Uncommunicative-Name.md
+- data/reek_docs/Uncommunicative-Parameter-Name.md
+- data/reek_docs/Uncommunicative-Variable-Name.md
+- data/reek_docs/Unused-Parameters.md
+- data/reek_docs/Unused-Private-Method.md
+- data/reek_docs/Utility-Function.md
+- data/reek_docs/Versioning-Policy.md
+- data/reek_docs/YAML-Reports.md
+- exe/snoot
+- lib/snoot.rb
+- lib/snoot/analyse_run.rb
+- lib/snoot/analyse_run/decision.rb
+- lib/snoot/analyse_run/result.rb
+- lib/snoot/analyser_orchestration.rb
+- lib/snoot/analyser_orchestration/default.rb
+- lib/snoot/analyser_orchestration/result_mapping.rb
+- lib/snoot/analyser_result.rb
+- lib/snoot/cli.rb
+- lib/snoot/cli/event.rb
+- lib/snoot/cli/pipeline.rb
+- lib/snoot/findings.rb
+- lib/snoot/render_report.rb
+- lib/snoot/run.rb
+- lib/snoot/state_error.rb
+- lib/snoot/value_types.rb
+- lib/snoot/version.rb
+- snoot.allium
+homepage: https://github.com/bkudria/snoot
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/bkudria/snoot
+  bug_tracker_uri: https://github.com/bkudria/snoot/issues
+  changelog_uri: https://github.com/bkudria/snoot/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: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Single-finding agent-targeted reek/flog/flay reporter.
+test_files: []