geet 0.30.0 → 0.31.0

data/docs/superpowers/plans/2026-07-12-ruby-4-upgrade.md

@@ -0,0 +1,111 @@
+# Ruby 4.0.5 Upgrade Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make Ruby 4.0.5 the project default while supporting Ruby 3.3 and newer.
+
+**Architecture:** Keep the upgrade confined to the project's Ruby version declaration, gem compatibility metadata, CI matrix, and any dependency or code incompatibility demonstrated by the verification suite. Do not refresh dependencies or refactor code without a Ruby 4.0.5 failure that requires it.
+
+**Tech Stack:** Ruby 4.0.5, Bundler 4.0.3, RSpec, Sorbet, RuboCop, GitHub Actions
+
+## Global Constraints
+
+- The project development Ruby version is exactly `4.0.5`.
+- The gem's minimum supported Ruby version is exactly `3.3.0`.
+- CI covers Ruby head, 4.0, 3.4, and 3.3.
+- Dependency and source changes require a demonstrated Ruby 4.0.5 incompatibility.
+
+---
+
+### Task 1: Ruby support declarations and compatibility verification
+
+**Files:**
+- Modify: `.ruby-version`
+- Modify: `geet.gemspec`
+- Modify: `.github/workflows/ci.yml`
+- Modify if required by Bundler: `Gemfile.lock`
+- Modify if required by a failing check: the source or dependency declaration responsible for that failure
+
+**Interfaces:**
+- Consumes: Ruby version selection by `.ruby-version`, RubyGems metadata from `geet.gemspec`, and the GitHub Actions Ruby matrix
+- Produces: a Ruby 4.0.5 development environment and a tested Ruby 3.3-or-newer compatibility contract
+
+- [ ] **Step 1: Confirm the existing declarations have the expected old values**
+
+Run:
+
+```bash
+test "$(< .ruby-version)" = "3.4.6" \
+  && rg -n 'required_ruby_version = ">= 3\.2\.0"' geet.gemspec \
+  && rg -n 'ruby-version: \[head, 4\.0, 3\.4, 3\.3, 3\.2\]' .github/workflows/ci.yml
+```
+
+Expected: exit status 0 and matches for the gemspec and CI matrix.
+
+- [ ] **Step 2: Update the Ruby support declarations**
+
+Set `.ruby-version` to:
+
+```text
+4.0.5
+```
+
+Set the gemspec declaration to:
+
+```ruby
+s.required_ruby_version = ">= 3.3.0"
+```
+
+Set the CI matrix to:
+
+```yaml
+ruby-version: [head, 4.0, 3.4, 3.3]
+```
+
+- [ ] **Step 3: Validate dependency resolution under Ruby 4.0.5**
+
+Run:
+
+```bash
+ruby --version \
+  && bundle check
+```
+
+Expected: Ruby reports `ruby 4.0.5`; Bundler reports that all dependencies are satisfied. If `bundle check` reports missing dependencies, run `bundle install` and retain only lockfile changes required for Ruby 4.0.5.
+
+- [ ] **Step 4: Run the project verification suite**
+
+Run:
+
+```bash
+bundle exec rspec \
+  && bundle exec srb typecheck \
+  && bundle exec rubocop \
+  && bundle exec rake build
+```
+
+Expected: all specs pass, Sorbet reports no errors, RuboCop reports no offenses, and RubyGems builds the gem. If a command fails because of Ruby 4.0.5, make the smallest source or dependency change that resolves that specific failure, then rerun the entire command sequence.
+
+- [ ] **Step 5: Check declarations and the resulting diff**
+
+Run:
+
+```bash
+test "$(< .ruby-version)" = "4.0.5" \
+  && rg -n 'required_ruby_version = ">= 3\.3\.0"' geet.gemspec \
+  && rg -n 'ruby-version: \[head, 4\.0, 3\.4, 3\.3\]' .github/workflows/ci.yml \
+  && ! rg -n '3\.4\.6|required_ruby_version = ">= 3\.2\.0"|ruby-version: \[head, 4\.0, 3\.4, 3\.3, 3\.2\]' . --glob '!docs/superpowers/**' --glob '!.git/**' \
+  && git diff --check \
+  && git status --short
+```
+
+Expected: exit status 0, only intended files are modified, and the diff has no whitespace errors.
+
+- [ ] **Step 6: Commit the upgrade**
+
+```bash
+git add .ruby-version geet.gemspec .github/workflows/ci.yml Gemfile.lock \
+  && git commit -m "Upgrade development Ruby to 4.0.5"
+```
+
+Omit `Gemfile.lock` from `git add` if it did not change. Add any verified compatibility fix files to the same command.

data/docs/superpowers/specs/2026-07-12-pre-existing-build-and-ci-fixes-design.md

@@ -0,0 +1,15 @@
+# Pre-existing Build and CI Fixes Design
+
+## Scope
+
+Fix the two pre-existing project issues exposed during Ruby 4.0.5 verification: the CI test job supplies the wrong token variable, and Rake does not define Bundler's standard gem tasks.
+
+## Changes
+
+- Rename the CI environment key from `GITHUB_API_TOKEN` to `GH_TOKEN`, matching the application, README, and test harness contract.
+- Require `bundler/gem_tasks` from `Rakefile` so `rake build` and the standard Bundler gem tasks are available.
+- Do not add token aliases, fallback credentials, dependency updates, or unrelated build changes.
+
+## Verification
+
+Run the specs using the same `GH_TOKEN` environment contract as CI, then run Sorbet, RuboCop, the default Rake task, and `rake build`. Remove the generated gem artifact and confirm the diff contains only the CI workflow and Rakefile changes.

data/docs/superpowers/specs/2026-07-12-repo-create-design.md

@@ -0,0 +1,43 @@
+# Repository creation design
+
+## Goal
+
+Add `geet repo create` to create a GitHub repository from the current local Git repository, configure remotes, push the current branch, and make that branch the GitHub default branch.
+
+## Command
+
+```text
+geet repo create [-v|--visibility private|public] [-u|--upstream ADDRESS]
+```
+
+The repository name is the basename of the current directory.
+
+Without `--upstream`, `--visibility` selects a private or public repository. If it is omitted, Geet prompts the user to choose between `private` and `public`.
+
+With `--upstream`, Geet creates a GitHub fork. GitHub determines the fork visibility, so Geet does not prompt for visibility and rejects an explicitly passed `--visibility`. `ADDRESS` may use any GitHub clone-address format Geet can resolve. Geet preserves the supplied address unchanged when configuring the local `upstream` remote.
+
+## Architecture
+
+The command decoder registers `repo.create`, and the launcher dispatches it without constructing `Git::Repository`, which assumes an existing `origin`.
+
+`Services::CreateRepo` coordinates the complete workflow. A GitHub repository API object performs authenticated-user lookup, repository or fork creation, fork availability checks, and default-branch updates. `Utils::GitClient` exposes the local Git operations required by the service.
+
+## Workflow
+
+Before changing local or remote state, the service verifies that the current directory is a Git repository with a named branch and at least one commit. It fails if `origin` exists. In fork mode, it also fails if `upstream` exists. It validates visibility and the incompatibility between `--visibility` and `--upstream` during this preflight.
+
+Normal mode creates a repository for the authenticated GitHub user with the selected visibility. Fork mode extracts the upstream repository path, requests a fork named after the current directory, and waits until GitHub makes the asynchronous fork available.
+
+The service adds the created repository as `origin` using `git@github.com:OWNER/REPOSITORY.git`. In fork mode, it also adds the supplied address as `upstream`. It pushes the current branch to `origin` with upstream tracking, then updates the GitHub repository's default branch to the pushed branch.
+
+On success, the command prints the created repository address and confirms the pushed default branch.
+
+## Failure handling
+
+Preflight failures occur before GitHub repository creation. GitHub API and Git command errors retain their existing messages and stop the workflow immediately.
+
+If a step after repository creation fails, Geet does not delete the GitHub repository or remove configured remotes. The retained state allows manual correction without destructive rollback.
+
+## Testing
+
+Tests cover command decoding and dispatch, prompted and explicit visibility, invalid visibility, the `--upstream` and `--visibility` conflict, existing remotes, normal creation, asynchronous fork creation, GitHub address parsing, remote configuration, pushing with upstream tracking, default-branch updates, success output, and stopping after failures.

data/docs/superpowers/specs/2026-07-12-ruby-4-upgrade-design.md

@@ -0,0 +1,17 @@
+# Ruby 4.0.5 Upgrade Design
+
+## Scope
+
+Use Ruby 4.0.5 as the project development version, raise the gem's minimum supported Ruby version from 3.2 to 3.3, and retain CI coverage for every supported Ruby minor version through 4.0 plus Ruby head.
+
+## Changes
+
+- Set `.ruby-version` to `4.0.5`.
+- Set `required_ruby_version` to `>= 3.3.0` in `geet.gemspec`.
+- Remove Ruby 3.2 from the CI matrix while retaining Ruby head, 4.0, 3.4, and 3.3.
+- Re-resolve dependencies only if Ruby 4.0.5 requires lockfile changes.
+- Make code or dependency changes only for incompatibilities demonstrated by verification.
+
+## Verification
+
+Under Ruby 4.0.5, install the locked bundle and run the RSpec suite, Sorbet typecheck, RuboCop, and gem build. Confirm the lockfile and repository contain no remaining declarations that incorrectly make Ruby 3.2 a supported version or Ruby 3.4.6 the development version.

data/geet.gemspec

@@ -6,9 +6,9 @@ Gem::Specification.new do |s|
   s.name        = "geet"
   s.version     = Geet::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.required_ruby_version = ">= 3.2.0"
+  s.required_ruby_version = ">= 3.3.0"
   s.authors     = ["Saverio Miroddi"]
-  s.date        = "2026-05-12"
+  s.date        = "2026-07-24"
   s.email       = ["saverio.pub2@gmail.com"]
   s.homepage    = "https://github.com/saveriomiroddi/geet"
   s.summary     = "Commandline interface for performing SCM host operations, eg. create a PR on GitHub"
@@ -17,12 +17,12 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency "base64", "~> 0.3.0"
   s.add_runtime_dependency "ostruct", "~> 0.6.3"
-  s.add_runtime_dependency "simple_scripting", "~> 0.14.0"
+  s.add_runtime_dependency "simple_scripting", "~> 0.14"
   s.add_runtime_dependency "sorbet-runtime", "= 0.6.12883"
   s.add_runtime_dependency "tty-prompt", "~> 0.23.1"
   s.add_runtime_dependency "zeitwerk", "~> 2.7"
 
-  s.add_development_dependency "rake", "~> 12.3"
+  s.add_development_dependency "rake", "~> 13.3"
 
   s.files         = `git ls-files`.split("\n")
   s.executables   << "geet"

data/lib/geet/commandline/commands.rb

@@ -18,6 +18,7 @@ module Geet
       PR_MERGE_COMMAND = T.let("pr.merge", String)
       PR_OPEN_COMMAND = T.let("pr.open", String)
       REPO_ADD_UPSTREAM_COMMAND = T.let("repo.add_upstream", String)
+      REPO_CREATE_COMMAND = T.let("repo.create", String)
       REPO_OPEN_COMMAND = T.let("repo.open", String)
     end
   end

data/lib/geet/commandline/configuration.rb

@@ -111,6 +111,12 @@ module Geet
         long_help: "Add the upstream repository to the current repository (configuration).",
       ], T::Array[T.any(T::Hash[T.untyped, T.untyped], T::Array[String])])
 
+      REPO_CREATE_OPTIONS = T.let([
+        ["-v", "--visibility private|public", "Repository visibility"],
+        ["-u", "--upstream address", "Create a fork of this repository"],
+        long_help: "Create a GitHub repository from the current directory.",
+      ], T::Array[T.any(T::Hash[T.untyped, T.untyped], T::Array[String])])
+
       REPO_OPEN_OPTIONS = T.let([
         ["-u", "--upstream",                                "Open the upstream repository"],
         long_help: "Open the current repository in the browser",
@@ -144,6 +150,7 @@ module Geet
         },
         "repo" => {
           "add_upstream" => REPO_ADD_UPSTREAM_OPTIONS,
+          "create" => REPO_CREATE_OPTIONS,
           "open" => REPO_OPEN_OPTIONS,
         },
       }, T::Hash[String, T::Array[T.untyped]])

data/lib/geet/github/repository.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Geet
+  module Github
+    class Repository
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :full_name
+
+      sig { returns(String) }
+      attr_reader :html_url
+
+      sig { returns(String) }
+      attr_reader :ssh_url
+
+      sig {
+        params(
+          name: String,
+          visibility: String,
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::Repository)
+      }
+      def self.create(name, visibility, api_interface)
+        response = api_interface.send_request("/user/repos", data: {name:, private: visibility == "private"})
+        from_response(response, api_interface)
+      end
+
+      sig {
+        params(
+          upstream_path: String,
+          name: String,
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::Repository)
+      }
+      def self.fork(upstream_path, name, api_interface)
+        response = api_interface.send_request("/repos/#{upstream_path}/forks", data: {name:})
+        from_response(response, api_interface)
+      end
+
+      sig {
+        params(
+          path: String,
+          api_interface: Geet::Github::ApiInterface
+        ).returns(Geet::Github::Repository)
+      }
+      def self.fetch(path, api_interface)
+        response = api_interface.send_request("/repos/#{path}")
+        from_response(response, api_interface)
+      end
+
+      sig {
+        params(
+          response: T::Hash[String, T.untyped],
+          api_interface: Geet::Github::ApiInterface
+        ).void
+      }
+      def initialize(response, api_interface)
+        @full_name = T.let(T.cast(response.fetch("full_name"), String), String)
+        @html_url = T.let(T.cast(response.fetch("html_url"), String), String)
+        @ssh_url = T.let(T.cast(response.fetch("ssh_url"), String), String)
+        @api_interface = T.let(api_interface, Geet::Github::ApiInterface)
+      end
+
+      sig { params(branch: String).void }
+      def update_default_branch(branch)
+        @api_interface.send_request("/repos/#{@full_name}", data: {default_branch: branch}, http_method: :patch)
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig {
+          params(
+            response: T.untyped,
+            api_interface: Geet::Github::ApiInterface
+          ).returns(Geet::Github::Repository)
+        }
+        def from_response(response, api_interface)
+          new(T.cast(response, T::Hash[String, T.untyped]), api_interface)
+        end
+      end
+    end
+  end
+end

data/lib/geet/services/create_repo.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "stringio"
+require "tty-prompt"
+
+module Geet
+  module Services
+    class CreateRepo
+      extend T::Sig
+
+      VISIBILITIES = T.let(["private", "public"].freeze, T::Array[String])
+      FORK_ATTEMPTS = 30
+      FORK_RETRY_DELAY = 1
+      DEFAULT_SLEEPER = T.let(->(delay) { Kernel.sleep(delay) }, T.proc.params(delay: Integer).void)
+
+      sig {
+        params(
+          directory: String,
+          out: T.any(IO, StringIO),
+          git_client: Utils::GitClient,
+          api_interface: T.nilable(Github::ApiInterface),
+          prompt: TTY::Prompt,
+          sleeper: T.proc.params(delay: Integer).void,
+          fork_attempts: Integer
+        ).void
+      }
+      def initialize(directory: Dir.pwd, out: $stdout, git_client: Utils::GitClient.new, api_interface: nil, prompt: TTY::Prompt.new, sleeper: DEFAULT_SLEEPER, fork_attempts: FORK_ATTEMPTS)
+        @directory = directory
+        @out = out
+        @git_client = git_client
+        @api_interface = T.let(
+          api_interface || Github::ApiInterface.new(ENV["GH_TOKEN"] || raise("GH_TOKEN not set!")),
+          Github::ApiInterface
+        )
+        @prompt = prompt
+        @sleeper = sleeper
+        @fork_attempts = fork_attempts
+      end
+
+      sig { params(visibility: T.nilable(String), upstream: T.nilable(String)).returns(Github::Repository) }
+      def execute(visibility: nil, upstream: nil)
+        preflight(visibility:, upstream:)
+
+        name = File.basename(@directory)
+        branch = @git_client.current_branch
+        selected_visibility = T.let(nil, T.nilable(String))
+        selected_visibility = visibility || T.cast(@prompt.select("Visibility:", VISIBILITIES), String) if !upstream
+        repository = upstream ? create_fork(name, upstream) : Github::Repository.create(name, selected_visibility, @api_interface)
+
+        @git_client.add_remote(Utils::GitClient::ORIGIN_NAME, repository.ssh_url)
+        @git_client.add_remote(Utils::GitClient::UPSTREAM_NAME, upstream) if upstream
+        @git_client.push(remote_branch: branch)
+        repository.update_default_branch(branch)
+        @out.puts "Repository address: #{repository.html_url}"
+        @out.puts "Default branch: #{branch}"
+        repository
+      end
+
+      private
+
+      sig { params(name: String, upstream: String).returns(Github::Repository) }
+      def create_fork(name, upstream)
+        upstream_path = @git_client.remote_path(upstream)
+        provisional_repository = Github::Repository.fork(upstream_path, name, @api_interface)
+        wait_for_fork(provisional_repository.full_name)
+      end
+
+      sig { params(full_name: String).returns(Github::Repository) }
+      def wait_for_fork(full_name)
+        @fork_attempts.times do |attempt|
+          begin
+            return Github::Repository.fetch(full_name, @api_interface)
+          rescue Shared::HttpError => error
+            raise if error.code != 404
+            @sleeper.call(FORK_RETRY_DELAY) if attempt < @fork_attempts - 1
+          end
+        end
+
+        raise "Timed out waiting for fork #{full_name}"
+      end
+
+      sig { params(visibility: T.nilable(String), upstream: T.nilable(String)).void }
+      def preflight(visibility:, upstream:)
+        validate_commits
+        validate_remotes(upstream)
+        validate_visibility(visibility, upstream)
+      end
+
+      sig { void }
+      def validate_commits
+        raise "The repository has no commits!" if !@git_client.head_commit?
+      end
+
+      sig { params(upstream: T.nilable(String)).void }
+      def validate_remotes(upstream)
+        raise 'Remote "origin" already exists!' if @git_client.remote_defined?(Utils::GitClient::ORIGIN_NAME)
+        raise 'Remote "upstream" already exists!' if upstream && @git_client.remote_defined?(Utils::GitClient::UPSTREAM_NAME)
+      end
+
+      sig { params(visibility: T.nilable(String), upstream: T.nilable(String)).void }
+      def validate_visibility(visibility, upstream)
+        raise "Visibility can't be specified with upstream!" if visibility && upstream
+        raise "Visibility must be private or public!" if visibility && !VISIBILITIES.include?(visibility)
+      end
+    end
+  end
+end

data/lib/geet/services/open_repo.rb

@@ -12,10 +12,8 @@ module Geet
 
       DEFAULT_GIT_CLIENT = Utils::GitClient.new
 
-      sig { params(repository: Git::Repository, out: IO, git_client: Utils::GitClient).void }
-      def initialize(repository, out: $stdout, git_client: DEFAULT_GIT_CLIENT)
-        @repository = repository
-        @out = out
+      sig { params(git_client: Utils::GitClient).void }
+      def initialize(git_client: DEFAULT_GIT_CLIENT)
         @git_client = git_client
       end
 

data/lib/geet/utils/git_client.rb

@@ -182,6 +182,11 @@ module Geet
       # REPOSITORY/REMOTE QUERYING APIS
       ##########################################################################
 
+      sig { returns(T::Boolean) }
+      def head_commit?
+        execute_git_command("rev-parse --verify HEAD", allow_error: true, silent_stderr: true) != ""
+      end
+
       # Return the components of the remote, according to REMOTE_URL_REGEX; doesn't include the full
       # match.
       #
@@ -201,7 +206,14 @@ module Geet
       def path(upstream: false)
         remote_name_option = upstream ? {name: UPSTREAM_NAME} : {}
 
-        T.must(remote(**remote_name_option)[REMOTE_URL_REGEX, 4])
+        remote_path(remote(**remote_name_option))
+      end
+
+      sig { params(remote_url: String).returns(String) }
+      def remote_path(remote_url)
+        match = remote_url.match(REMOTE_URL_REGEX)
+        raise "Unexpected remote reference format: #{remote_url.inspect}" if !match
+        T.must(match[4])
       end
 
       sig { returns(String) }
@@ -225,10 +237,9 @@ module Geet
 
         if !remote_defined?(name)
           raise "Remote #{name.inspect} not found!"
-        elsif remote_url !~ REMOTE_URL_REGEX
-          raise "Unexpected remote reference format: #{remote_url.inspect}"
         end
 
+        remote_path(remote_url)
         remote_url
       end
 
@@ -287,7 +298,7 @@ module Geet
 
       sig { params(name: String, url: String).returns(String) }
       def add_remote(name, url)
-        execute_git_command("remote add #{name.shellescape} #{url}")
+        execute_git_command("remote add #{name.shellescape} #{url.shellescape}")
       end
 
       ##########################################################################

data/lib/geet/version.rb

@@ -2,5 +2,5 @@
 # typed: strict
 
 module Geet
-  VERSION = "0.30.0"
+  VERSION = "0.31.0"
 end