inquirex-tools 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2027915b1b69d07af80a30a63207731809243ae607da736ea2d558c2748c6c1f
+  data.tar.gz: 6c35d199ad702ffd061d90bf5fa5ebe17da1fc8b1f0d7722e3f8bf37676b3e4b
+SHA512:
+  metadata.gz: a97efe3bc05fc24445e9b40920ec073055305e26c92764a7977cea0152cd33a25c28ccca97cf3e129ced24150b5957f0a137c57bc10172c1054cea7a5300ddfb
+  data.tar.gz: 0a975ec1e72ad597bf19827d9fe5f5afe68523bfea5809729a23ae184ab61a380b7aeff9128df1e984042c307a9de6c4ea464c660bf668474e731aa78779664e

data/.github_changelog_generator

@@ -0,0 +1,5 @@
+user=inquirex
+project=inquirex-tools
+exclude-labels=duplicate,question,invalid,wontfix
+issues=false
+add-sections={"security":{"prefix":"### Security","labels":["security"]}}

data/CHANGELOG.md

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Konstantin Gredeskoul
+
+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,39 @@
+# Inquirex::Tools
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/inquirex/tools`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kigster/inquirex-tools.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "timeout"
+require "yard"
+
+def shell(*args)
+  puts "running: #{args.join(" ")}"
+  system(args.join(" "))
+end
+
+task :clean do
+  shell("rm -rf pkg/ tmp/ coverage/ doc/ ")
+end
+
+task gem: [:build] do
+  shell("gem install pkg/*")
+end
+
+task permissions: [:clean] do
+  # One traversal replaces a six-level glob chain that printed "No such file
+  # or directory" for every level this project does not have, skipped dotfiles
+  # entirely, and silently stopped at depth six. .git is pruned — its objects
+  # have no business being group-readable.
+  shell("find . -path ./.git -prune -o -type d -exec chmod o+rx,g+rx {} + -o -type f -exec chmod o+r,g+r {} +")
+end
+
+task build: :permissions
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files = %w[lib/**/*.rb exe/*.rb - README.md LICENSE.txt CHANGELOG.md]
+  t.options.unshift("--title", '"FlowEngine — DSL + AST for buildiong complex flows in Ruby."')
+  t.after = -> { exec("open doc/index.html") } if RUBY_PLATFORM =~ /darwin/
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/inquirex

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# The `inquirex` umbrella CLI. `inquirex-tty` ships its own `inquirex-tty`
+# binary; this gem owns the bare name so cross-family tooling has one entry
+# point and no two gems install a binary called `inquirex`.
+#
+#   inquirex versions             # lockstep parity across the family
+#   inquirex versions --set 0.8.0
+#   inquirex changelogs
+#
+# Inside a checkout, prefer the repo's own Gemfile over whatever rubygems has
+# installed globally — the same bootstrap inquirex-tty uses.
+gemfile = File.expand_path("../Gemfile", __dir__)
+if File.file?(gemfile)
+  ENV["BUNDLE_GEMFILE"] = gemfile
+  begin
+    require "bundler/setup"
+  rescue LoadError
+    # Bundler unavailable — fall through to priming $LOAD_PATH directly.
+  end
+end
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__)) if File.directory?("#{__dir__}/../lib")
+
+require "inquirex/tools"
+require "inquirex/tools/commands"
+
+Dry::CLI.new(Inquirex::Tools::Commands).call

data/lib/inquirex/tools/changelogs.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "workspace"
+
+module Inquirex
+  module Tools
+    # Regenerates CHANGELOG.md across the ecosystem from merged GitHub PRs.
+    #
+    # The generated files are disposable. `inquirex/INQUIREX_VERSION_LOG.md` is
+    # not, and is never touched here — a PR title records what merged, not what
+    # it means or what a consumer must do about it.
+    class Changelogs
+      # The gem is not installed for every Ruby the repos pin (inquirex pins
+      # 4.0.5), so the generator runs under one that has it rather than being
+      # installed into each.
+      DEFAULT_RUBY = "4.0.6"
+
+      # Never overwritten by generation, in any repo.
+      PROTECTED = %w[INQUIREX_VERSION_LOG.md].freeze
+
+      # @param workspace [Workspace]
+      # @param out [IO]
+      def initialize(workspace: Workspace.new, out: $stdout)
+        @workspace = workspace
+        @out = out
+      end
+
+      # @return [Array<String>] every repo carrying a generator config
+      def repositories
+        (Workspace::LOCKSTEP.keys + Workspace::CHANGELOG_ONLY).uniq.select do |name|
+          File.exist?(File.join(@workspace.root, name, ".github_changelog_generator"))
+        end
+      end
+
+      # Runs the generator in each repository.
+      #
+      # The token comes from `gh auth token` rather than a stored secret, so
+      # nothing here handles a credential in plain text and there is none to
+      # leak from the source.
+      #
+      # @param names [Array<String>] repositories, or all configured when empty
+      # @return [Boolean] true when every repository succeeded
+      def generate(*names)
+        token = `gh auth token 2>/dev/null`.strip
+        if token.empty?
+          @out.puts "ERROR: `gh auth token` returned nothing — run `gh auth login`"
+          return false
+        end
+
+        targets = names.flatten.compact
+        targets = repositories if targets.empty?
+        failed = targets.reject { |name| generate_one(name, token) }
+
+        report_failures(failed)
+        failed.empty?
+      end
+
+      private
+
+      # @param name [String] repository directory name
+      # @param token [String] GitHub token for the generator
+      # @return [Boolean] true on success or a deliberate skip
+      def generate_one(name, token)
+        dir = File.join(@workspace.root, name)
+        unless File.exist?(File.join(dir, ".github_changelog_generator"))
+          @out.puts format("  %<name>-16s SKIP (no .github_changelog_generator)", name: name)
+          return true
+        end
+
+        @out.print format("  %<name>-16s ", name: name)
+        env = { "CHANGELOG_GITHUB_TOKEN" => token, "RBENV_VERSION" => ENV.fetch("RBENV_VERSION", DEFAULT_RUBY) }
+        if system(env, "github_changelog_generator", chdir: dir, out: File::NULL, err: File::NULL)
+          @out.puts "ok (#{line_count(File.join(dir, "CHANGELOG.md"))} lines)"
+          true
+        else
+          @out.puts "FAILED"
+          false
+        end
+      end
+
+      # @param path [String]
+      # @return [Integer]
+      def line_count(path) = File.exist?(path) ? File.readlines(path).size : 0
+
+      # @param failed [Array<String>]
+      # @return [void]
+      def report_failures(failed)
+        return if failed.empty?
+
+        @out.puts
+        @out.puts "Failed: #{failed.join(", ")}"
+        @out.puts "Re-run one with output: cd <repo> && " \
+                  "CHANGELOG_GITHUB_TOKEN=$(gh auth token) github_changelog_generator"
+      end
+    end
+  end
+end

data/lib/inquirex/tools/commands/changelogs.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Inquirex
+  module Tools
+    module Commands
+      # Regenerates CHANGELOG.md across the ecosystem from merged GitHub PRs.
+      class Changelogs < Dry::CLI::Command
+        desc "Regenerate CHANGELOG.md from merged PRs"
+
+        argument :repos, type: :array, required: false,
+                         desc: "Repositories to regenerate (default: all configured)"
+
+        example [
+          "                    # every repo with a .github_changelog_generator",
+          "inquirex-js         # just one"
+        ]
+
+        # The GitHub token comes from `gh auth token`, so no secret is stored
+        # or passed on the command line. inquirex/INQUIREX_VERSION_LOG.md is
+        # hand-written and never touched.
+        #
+        # @param repos [Array<String>, nil]
+        # @return [void]
+        def call(repos: [], **)
+          exit(1) unless Inquirex::Tools::Changelogs.new.generate(*Array(repos))
+        rescue Inquirex::Tools::Error => e
+          warn "ERROR: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/inquirex/tools/commands/version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Inquirex
+  module Tools
+    module Commands
+      # Prints this tool's own version. See `versions` (plural) for the
+      # family's lockstep version.
+      class Version < Dry::CLI::Command
+        desc "Print inquirex-tools version"
+
+        # @return [void]
+        def call(**) = puts("inquirex-tools #{Inquirex::Tools::VERSION}")
+      end
+    end
+  end
+end

data/lib/inquirex/tools/commands/versions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Inquirex
+  module Tools
+    module Commands
+      # Reports and enforces version parity across the lockstep packages.
+      #
+      # Plural on purpose: `inquirex version` prints this tool's own version,
+      # `inquirex versions` manages the family's.
+      class Versions < Dry::CLI::Command
+        desc "Check, set, or preflight the family's lockstep version"
+
+        option :set, type: :string, desc: "Move every lockstep package to this version"
+        option :preflight, type: :boolean, default: false,
+                           desc: "Also check clean trees, main branch, and tags"
+
+        example [
+          "                      # report parity, exit 1 on drift",
+          "--set 0.8.0           # move all five packages",
+          "--preflight           # release readiness"
+        ]
+
+        # @param set [String, nil] target version
+        # @param preflight [Boolean]
+        # @return [void]
+        def call(set: nil, preflight: false, **)
+          versions = Inquirex::Tools::Versions.new
+          ok =
+            if set then versions.set(set)
+            elsif preflight then versions.preflight
+            else versions.check
+            end
+          exit(1) unless ok
+        rescue Inquirex::Tools::Error => e
+          warn "ERROR: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/inquirex/tools/commands.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+
+require_relative "commands/version"
+require_relative "commands/versions"
+require_relative "commands/changelogs"
+
+module Inquirex
+  module Tools
+    # dry-cli registry for the `inquirex` executable.
+    #
+    # `inquirex-tty` owns `inquirex-tty`; this gem owns the bare `inquirex`
+    # command, so cross-family tooling has one entry point and the two gems no
+    # longer install binaries with the same name.
+    module Commands
+      extend Dry::CLI::Registry
+
+      register "versions",   Versions
+      register "changelogs", Changelogs
+      register "version",    Version
+    end
+  end
+end

data/lib/inquirex/tools/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Inquirex
+  module Tools
+    VERSION = "0.8.0"
+  end
+end

data/lib/inquirex/tools/versions.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "rubygems/version"
+require_relative "workspace"
+
+module Inquirex
+  module Tools
+    # Reports and enforces version parity across the lockstep packages.
+    #
+    # @example Check for drift
+    #   Inquirex::Tools::Versions.new.check   # => false when versions differ
+    class Versions
+      # @param workspace [Workspace]
+      # @param out [IO] where report output goes
+      def initialize(workspace: Workspace.new, out: $stdout)
+        @workspace = workspace
+        @out = out
+      end
+
+      # Prints the current state of every lockstep package.
+      #
+      # @return [Boolean] true when all packages agree on one version
+      def check
+        versions = @workspace.versions
+        print_table(versions)
+        verdict(versions)
+      end
+
+      # Moves every lockstep package to one version.
+      #
+      # Refuses to move backwards: a version already published cannot be
+      # reissued, so the target must exceed every current value.
+      #
+      # @param version [String] target, MAJOR.MINOR.PATCH
+      # @return [Boolean] true when written
+      def set(version)
+        unless /\A\d+\.\d+\.\d+\z/.match?(version.to_s)
+          @out.puts "ERROR: #{version.inspect} is not MAJOR.MINOR.PATCH"
+          return false
+        end
+
+        current = @workspace.versions.values.compact
+        highest = current.max_by { Gem::Version.new(_1) }
+        if highest && Gem::Version.new(highest) > Gem::Version.new(version)
+          @out.puts "ERROR: #{version} is below the highest existing version (#{highest}) — versions only go forward"
+          return false
+        end
+
+        @out.puts "Setting all lockstep packages to #{version}:"
+        @workspace.versions.each do |name, was|
+          @workspace.write_version(name, version)
+          @out.puts format("  %-16s %s -> %s", name, was || "?", version)
+        end
+        @out.puts
+        @out.puts "Unchanged (excluded): #{Workspace::EXCLUDED.join(", ")}"
+        true
+      end
+
+      # Parity plus git readiness: clean tree, on main, tagged at the version.
+      #
+      # @return [Boolean] true when every package could be published now
+      def preflight
+        ok = check
+        target = @workspace.versions.values.compact.uniq.first
+        @out.puts
+        @out.puts "Release readiness:"
+
+        Workspace::LOCKSTEP.each_key do |name|
+          problems = readiness_problems(name, target)
+          @out.puts format("  %<name>-16s %<state>s", name: name, state: problems.empty? ? "ready" : problems.join(", "))
+          ok &&= problems.empty?
+        end
+
+        @out.puts
+        @out.puts ok ? "ALL READY — publish with `gem push` / `npm publish`" : "NOT READY — resolve the above"
+        ok
+      end
+
+      private
+
+      # @param versions [Hash{String => String, nil}]
+      # @return [void]
+      def print_table(versions)
+        @out.puts "Lockstep packages (#{Workspace::EXCLUDED.join(", ")} excluded by design):"
+        versions.each do |name, version|
+          @out.puts format("  %<name>-16s %<kind>-4s %<version>s",
+                           name: name, kind: Workspace::LOCKSTEP[name], version: version || "MISSING")
+        end
+        @out.puts
+      end
+
+      # @param versions [Hash{String => String, nil}]
+      # @return [Boolean] true when every package agrees on one version
+      def verdict(versions)
+        distinct = versions.values.compact.uniq
+        if versions.value?(nil)
+          @out.puts "DRIFT: a version could not be read (MISSING above)"
+          false
+        elsif distinct.one?
+          @out.puts "OK: all #{versions.size} at #{distinct.first}"
+          true
+        else
+          @out.puts "DRIFT: #{distinct.sort.join(", ")} — run `inquirex versions --set <version>`"
+          false
+        end
+      end
+
+      # Why a package is not publishable right now.
+      #
+      # @param name [String] package name
+      # @param target [String, nil] the version its tag must match
+      # @return [Array<String>] empty when ready
+      def readiness_problems(name, target)
+        state = @workspace.git_state(name)
+        return [ "no git checkout" ] if state[:clean].nil?
+
+        problems = []
+        problems << "DIRTY" unless state[:clean]
+        problems << "on #{state[:branch]}" unless state[:branch] == "main"
+        problems << "untagged" unless state[:tags].any? { |tag| tag.delete_prefix("v") == target }
+        problems
+      end
+    end
+  end
+end

data/lib/inquirex/tools/workspace.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Inquirex
+  module Tools
+    # Locates the Inquirex ecosystem checkout and reads each package's version.
+    #
+    # As gem executables these tools run from an rbenv shim, so `__dir__` says
+    # nothing about where the repositories live. The root is discovered by
+    # walking up from the working directory looking for the sibling checkouts,
+    # or taken from INQUIREX_ROOT.
+    class Workspace
+      # Packages that must always carry the same version. They share one
+      # serialization format — the gem defines the DSL and emits step JSON,
+      # inquirex-js renders it, inquirex-webui prints it back to DSL,
+      # inquirex-llm extends the vocabulary, and inquirex-tools is the tooling
+      # that ships alongside them. A verb present in one and absent in another
+      # does not fail loudly; it drops data.
+      #
+      # `inquirex-tty` is deliberately absent: a developer tool outside the
+      # wire contract, versioned on its own cadence.
+      LOCKSTEP = {
+        "inquirex" => :gem,
+        "inquirex-llm" => :gem,
+        "inquirex-tools" => :gem,
+        "inquirex-js" => :npm,
+        "inquirex-webui" => :npm
+      }.freeze
+
+      # Excluded from lockstep, documented so the omission reads as deliberate.
+      EXCLUDED = %w[inquirex-tty].freeze
+
+      # Repositories that carry a generated CHANGELOG.md but are not versioned
+      # in lockstep.
+      CHANGELOG_ONLY = %w[inquirex-tty qualified-at].freeze
+
+      GEM_VERSION_RE = /VERSION\s*=\s*"([^"]+)"/
+
+      # Directories whose presence identifies the ecosystem root.
+      MARKERS = %w[inquirex inquirex-js].freeze
+
+      # @return [String] absolute path to the ecosystem root
+      attr_reader :root
+
+      # @param root [String, nil] explicit root; discovered when nil
+      # @raise [Error] when no root can be found
+      def initialize(root: nil)
+        @root = root || ENV["INQUIREX_ROOT"] || self.class.discover
+        raise Error, "cannot find the Inquirex workspace — run inside it or set INQUIREX_ROOT" if @root.nil?
+      end
+
+      # Walks up from the working directory looking for a directory that holds
+      # the marker checkouts.
+      #
+      # @return [String, nil]
+      def self.discover
+        dir = Dir.pwd
+        loop do
+          return dir if MARKERS.all? { |m| Dir.exist?(File.join(dir, m)) }
+
+          parent = File.dirname(dir)
+          return nil if parent == dir
+
+          dir = parent
+        end
+      end
+
+      # @param name [String] package name
+      # @return [String, nil] path to the file carrying its version
+      def version_file(name)
+        case LOCKSTEP[name]
+        when :npm then existing(File.join(name, "package.json"))
+        when :gem then gem_version_file(name)
+        end
+      end
+
+      # @param name [String] package name
+      # @return [String, nil] the current version, or nil when unreadable
+      def version_of(name)
+        file = version_file(name)
+        return nil unless file && File.exist?(file)
+
+        LOCKSTEP[name] == :gem ? File.read(file)[GEM_VERSION_RE, 1] : JSON.parse(File.read(file))["version"]
+      end
+
+      # @return [Hash{String => String, nil}] every lockstep package's version
+      def versions = LOCKSTEP.keys.to_h { |n| [n, version_of(n)] }
+
+      # Rewrites one package's version. Edits the single version line rather
+      # than re-emitting the file, so formatting and comments survive.
+      #
+      # @param name [String] package name
+      # @param version [String] new version
+      # @return [void]
+      def write_version(name, version)
+        file = version_file(name)
+        raise Error, "no version file for #{name}" unless file
+
+        src = File.read(file)
+        updated =
+          if LOCKSTEP[name] == :gem
+            src.sub(GEM_VERSION_RE, %(VERSION = "#{version}"))
+          else
+            src.sub(/"version":\s*"[^"]*"/, %("version": "#{version}"))
+          end
+        File.write(file, updated)
+      end
+
+      # @param name [String] repository directory name
+      # @return [Hash] :clean, :branch, :tags — all nil when not a checkout
+      def git_state(name)
+        dir = File.join(@root, name)
+        return { clean: nil, branch: nil, tags: [] } unless File.exist?(File.join(dir, ".git"))
+
+        {
+          clean: `git -C #{dir} status --porcelain 2>/dev/null`.strip.empty?,
+          branch: `git -C #{dir} rev-parse --abbrev-ref HEAD 2>/dev/null`.strip,
+          tags: `git -C #{dir} tag --points-at HEAD 2>/dev/null`.split("\n").map(&:strip).reject(&:empty?)
+        }
+      end
+
+      private
+
+      # A gem's version.rb, chosen by content rather than by name.
+      #
+      # `lib/**/version.rb` can match more than one file — this gem has both
+      # `lib/inquirex/tools/version.rb` and the CLI's
+      # `lib/inquirex/tools/commands/version.rb`, and the latter sorts first
+      # alphabetically. Requiring the VERSION constant excludes impostors;
+      # preferring the shallowest path picks the canonical one when several
+      # legitimately define it.
+      #
+      # @param name [String] package name
+      # @return [String, nil]
+      def gem_version_file(name)
+        Dir.glob(File.join(@root, name, "lib/**/version.rb"))
+           .select { |file| File.read(file).match?(GEM_VERSION_RE) }
+           .min_by { |file| [file.count("/"), file] }
+      end
+
+      # @param relative [String]
+      # @return [String, nil] absolute path when it exists
+      def existing(relative)
+        path = File.join(@root, relative)
+        File.exist?(path) ? path : nil
+      end
+    end
+  end
+end

data/lib/inquirex/tools.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "tools/version"
+require_relative "tools/workspace"
+require_relative "tools/versions"
+require_relative "tools/changelogs"
+
+module Inquirex
+  # Shared tooling for the Inquirex family.
+  #
+  # This gem is the home for anything several packages need but none of them
+  # owns — release plumbing today, and whatever else turns out to be duplicated
+  # across the gems tomorrow.
+  #
+  # It ships developer executables, so it may take dependencies the runtime
+  # gems cannot. That is the point of separating it: `inquirex` itself is
+  # required to have zero runtime dependencies, and nothing added here changes
+  # that, because nothing here is loaded by the runtime gems.
+  #
+  # Executables:
+  #
+  # - `inquirex-version`    — version parity across the lockstep packages
+  # - `inquirex-changelogs` — regenerate CHANGELOG.md from merged PRs
+  #
+  # @example Check whether the family is releasable
+  #   Inquirex::Tools::Versions.new.preflight  # => true when every package is ready
+  module Tools
+    class Error < StandardError; end
+  end
+end

data/sig/inquirex/tools.rbs

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

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: inquirex-tools
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Konstantin Gredeskoul
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |
+  Ships the `inquirex` command: lockstep version management across the
+  Inquirex gems and npm packages, changelog regeneration, and release
+  preflight checks. A developer tool — it never depends on the gems it
+  manages, so `inquirex` itself stays dependency-free.
+email:
+- kigster@gmail.com
+executables:
+- inquirex
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".github_changelog_generator"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/inquirex
+- lib/inquirex/tools.rb
+- lib/inquirex/tools/changelogs.rb
+- lib/inquirex/tools/commands.rb
+- lib/inquirex/tools/commands/changelogs.rb
+- lib/inquirex/tools/commands/version.rb
+- lib/inquirex/tools/commands/versions.rb
+- lib/inquirex/tools/version.rb
+- lib/inquirex/tools/versions.rb
+- lib/inquirex/tools/workspace.rb
+- sig/inquirex/tools.rbs
+homepage: https://github.com/kigster/inquirex-tools
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/kigster/inquirex-tools
+  source_code_uri: https://github.com/kigster/inquirex-tools
+  changelog_uri: https://github.com/kigster/inquirex-tools/blob/main/CHANGELOG.md
+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: 4.0.17
+specification_version: 4
+summary: Release tooling for the Inquirex package family
+test_files: []