ace-git-forgejo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dd545a2d89b063b16fe426301be445f5fd96e9831c90f4f3cbc8bcdf5a6cd535
+  data.tar.gz: a0d960a767bb9c94286d1f3cf0f0d2faa90bff6e1d27e798acd4559c4944f987
+SHA512:
+  metadata.gz: 61487148163544e819c66ad42c63be3de3d350b641162650d49094f78186673820dbf47a4ae9fa29ccddacc333eebddeb6f884c5e8259496a780a62f101c7ce1
+  data.tar.gz: 1c3d7f3985b77e4cb0104b7be71c22245c63fdacc4fd4f3148931fbee5d57f335565edaf4dcf7fdd5b8c1aab95246494293909eea61ff15ad227406522c3f175

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to ace-git-forgejo will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Fixed
+
+- Parse real `fj` v0.6.0 minimal-style output: strip Unicode bidi isolate/pop-directional marks (U+2066–U+2069, U+202A–U+202E, U+200E/U+200F, soft hyphen) that `[[:cntrl:]]` does not cover. Real `fj` output wraps dynamic fields (titles, numbers, URLs) in U+2068/U+2069, which made `parse_pr_view` return `nil` and leaked marks into repo-URL evidence.
+- Listing API: `fj pr search` has no `--limit` flag on real `fj`; the flag made both listing paths fail unconditionally. Fetch all and cap `recent_pull_requests` client-side after the newest-first sort.
+- Presence probe: `fj` rejects `--version` ("unexpected argument"), so `check_available!` misclassified healthy installs as missing. Probe with the supported `fj version` subcommand; classified `ProviderCliMissingError` semantics unchanged.
+- Captured real `fj` outputs (pr view/commits/search, issue view, repo view) as fixtures; parser, executor, provider, and contract-parity suites assert against them.
+
+## [0.1.0] - 2026-09-21
+
+### Added
+
+- Initial Forgejo provider package implementing the forge-neutral ace-git provider contract.
+- Owns all `fj` CLI invocation, minimal-style output parsing, and authentication
+  verification (foundation chunk F0, task 8wk.t.l1e; the ace-git core previously
+  had zero Forgejo support).
+- Normalized evidence translation for pull requests, issues, Actions checks, and
+  repository metadata, with the shared classified failure taxonomy.
+- Ad-hoc curl fallbacks are strictly excluded; `fj` failures surface as
+  classified provider failures.
+- Shared provider-contract parity suite coverage against scripted fakes.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michal Czyz
+
+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,23 @@
+# ace-git-forgejo
+
+Forgejo provider for the forge-neutral [`ace-git`](../ace-git) core.
+
+This package owns **all** Forgejo-specific behavior for ACE:
+
+- `fj` CLI invocation (with timeout handling and structured output)
+- `fj` minimal-style output parsing and normalization
+- `fj` authentication verification (`fj auth list` per configured server host)
+- Forgejo-specific identifier formats (including `/pulls/N` web URLs)
+
+It implements the provider contract defined by the core
+(`Ace::Git::Providers::Base`) and registers itself under the `:forgejo`
+provider type, so consumers resolve it through
+`Ace::Git::Providers.for(server)` and read normalized evidence types
+(`Ace::Git::ProviderPullRequest`, `Ace::Git::ProviderIssue`,
+`Ace::Git::ProviderCheck`, `Ace::Git::ProviderRepository`).
+
+Failures are classified with the shared taxonomy
+(`ProviderCliMissingError`, `ProviderAuthenticationError`,
+`ProviderUnreachableError`, `ProviderMalformedOutputError`,
+`ProviderObjectNotFoundError`). Ad-hoc curl fallbacks are strictly
+forbidden; there is no silent fallback of any kind.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.warning = false
+  t.verbose = false
+end
+
+task default: :test

data/lib/ace/git/forgejo/cli_executor.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Ace
+  module Git
+    module Forgejo
+      # Executes the Forgejo CLI (`fj`) with timeout and structured output.
+      #
+      # Owns every `fj` subprocess invocation for ACE. A test runner may be
+      # injected instead of spawning real processes (see Providers::Base).
+      module CliExecutor
+        DEFAULT_TIMEOUT = 30
+        BINARY = "fj"
+
+        class << self
+          # Execute an `fj` command with timeout and structured output.
+          #
+          # @param args [Array<String>] full argument vector after the binary
+          # @param timeout [Integer, nil] seconds before the call times out
+          # @param runner [Proc, nil] injectable command runner for tests
+          # @return [Hash] {success:, stdout:, stderr:, exit_code:}
+          # @raise [Ace::Git::ProviderCliMissingError] when `fj` is missing
+          # @raise [Ace::Git::ProviderUnreachableError] when the call times out
+          def execute(args, timeout: nil, runner: nil)
+            timeout_seconds = timeout || Ace::Git.network_timeout || DEFAULT_TIMEOUT
+            result = run_command([BINARY] + args, timeout_seconds, runner)
+            if result == :timeout
+              raise Ace::Git::ProviderUnreachableError,
+                "fj command timed out after #{timeout_seconds} seconds: #{args.join(" ")}"
+            end
+
+            result
+          end
+
+          # Probe whether the `fj` binary is installed and runnable.
+          # `fj` has no `--version` flag (it rejects it with "unexpected
+          # argument"); the supported presence probe is `fj version`.
+          def installed?(runner: nil)
+            result = execute(["version"], runner: runner)
+            result != :timeout && result[:success]
+          rescue Ace::Git::ProviderCliMissingError
+            false
+          end
+
+          # Probe whether the resolved server host has a configured `fj` login.
+          # `fj auth list` exits nonzero when no instance is configured and
+          # prints one host per line otherwise.
+          def authenticated?(host, runner: nil)
+            result = execute(["auth", "list"], runner: runner)
+            return false unless result[:success]
+
+            hosts = result[:stdout].to_s.lines.map(&:strip).reject(&:empty?)
+            return hosts.any? unless host
+
+            hosts.any? { |line| line.include?(host.to_s) }
+          rescue Ace::Git::ProviderCliMissingError
+            false
+          end
+
+          # @raise [Ace::Git::ProviderCliMissingError] when `fj` is missing
+          def check_installed!(runner: nil)
+            return true if installed?(runner: runner)
+
+            raise Ace::Git::ProviderCliMissingError,
+              "Forgejo CLI (fj) is not installed or not runnable; install the Forgejo CLI and retry"
+          end
+
+          # @raise [Ace::Git::ProviderAuthenticationError] when unauthenticated
+          def check_authenticated!(host: nil, runner: nil)
+            return true if authenticated?(host, runner: runner)
+
+            raise Ace::Git::ProviderAuthenticationError,
+              "Forgejo CLI (fj) has no usable login for #{host || "the target host"}; " \
+              "check fj auth list"
+          end
+
+          # Run a full argument vector against `fj`.
+          #
+          # @return [Hash] result hash, or :timeout sentinel on timeout
+          def run_command(command, timeout_seconds, runner = nil)
+            if runner
+              call_runner(runner, command, timeout_seconds)
+            else
+              spawn_with_timeout(command, timeout_seconds)
+            end
+          end
+
+          private
+
+          def call_runner(runner, command, timeout_seconds)
+            runner.call(args: command, timeout: timeout_seconds, env: {"LC_ALL" => "C"})
+          rescue StandardError => e
+            {success: false, stdout: "", stderr: e.message, exit_code: 1}
+          end
+
+          def spawn_with_timeout(command, timeout_seconds)
+            stdout_str, stderr_str, status = Timeout.timeout(timeout_seconds) do
+              Open3.capture3({"LC_ALL" => "C"}, *command)
+            end
+
+            {
+              success: status.success?,
+              stdout: stdout_str,
+              stderr: stderr_str,
+              exit_code: status.exitstatus
+            }
+          rescue Timeout::Error
+            :timeout
+          rescue Errno::ENOENT
+            raise Ace::Git::ProviderCliMissingError,
+              "Forgejo CLI (fj) is not installed or not runnable; install the Forgejo CLI and retry"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/forgejo/parsers.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Forgejo
+      # Parse `fj` human-oriented output (minimal style) into structured data.
+      #
+      # `fj` has no JSON output mode, so the provider owns parsers for the
+      # stable text formats. All parsers are pure functions over strings.
+      module Parsers
+        # Invisible bidi isolate/pop-directional marks. Real `fj` (v0.6.0) wraps
+        # dynamic fields (titles, numbers, URLs) in U+2068/U+2069 even in minimal
+        # style; they are Unicode Cf format characters, so `[[:cntrl:]]` does not
+        # cover them and they must be stripped explicitly. Includes the full
+        # isolate/pop set (U+2066-U+2069, U+202A-U+202E), directional marks
+        # (U+200E/U+200F), and the soft hyphen.
+        BIDI_MARKS = /[\u00ad\u200e\u200f\u202a-\u202e\u2066-\u2069]/.freeze
+
+        # Strip control characters, bidi isolate/pop-directional marks, and
+        # surrounding whitespace from an `fj` line.
+        def self.clean(line)
+          line.to_s.gsub(/[[:cntrl:]]/, "").gsub(BIDI_MARKS, "").strip
+        end
+
+        # Parse `fj pr view <ID>` output.
+        #
+        # Layout (minimal style):
+        #   Ship the provider contract #25
+        #   By lab-builder - Merged - +252 -8
+        #   From `owner/repo:head-branch` into `main`
+        #
+        # @return [Hash, nil] {number:, title:, author:, state:, head_ref:, base_ref:}
+        def self.parse_pr_view(text)
+          lines = text.to_s.lines.map { |line| clean(line) }.reject(&:empty?)
+          return nil if lines.empty?
+
+          title_line = lines[0]
+          numbered = title_line.match(/^(?<title>.+?)\s+#(?<number>\d+)\z/)
+          return nil unless numbered
+
+          info = {
+            number: numbered[:number].to_i,
+            title: numbered[:title],
+            author: nil,
+            state: nil,
+            head_ref: nil,
+            base_ref: nil
+          }
+
+          byline = lines[1].to_s
+          if (match = byline.match(/\ABy\s+(?<author>\S+)\s+[-\u2013\u2014]\s+(?<state>\w+)/))
+            info[:author] = match[:author]
+            info[:state] = normalize_state(match[:state])
+          end
+
+          refs = lines.find { |line| line.start_with?("From ") }
+          if (match = refs.to_s.match(/\AFrom\s+`(?:[^`:]+:)?(?<head>[^`]+)`\s+into\s+`(?<base>[^`]+)`\z/))
+            info[:head_ref] = match[:head]
+            info[:base_ref] = match[:base]
+          end
+
+          info
+        end
+
+        # Parse `fj pr view <ID> commits` output; the first commit line carries
+        # the head sha.
+        #
+        # @return [String, nil] head commit sha
+        def self.parse_head_sha(text)
+          match = text.to_s.match(/^commit\s+(?<sha>[0-9a-f]{7,64})\b/)
+          match && match[:sha]
+        end
+
+        # Parse `fj pr search` / issue search listing output.
+        #
+        # Layout (minimal style):
+        #   25 pull requests
+        #   #31: Wire status to providers (by lab-builder)
+        #
+        # @return [Array<Hash>] {number:, title:, author:}
+        def self.parse_search(text)
+          text.to_s.lines.map { |line| clean(line) }.filter_map do |line|
+            match = line.match(/\A#(?<number>\d+):\s+(?<title>.+?)\s+\(by\s+(?<author>[^)]+)\)\z/)
+            next nil unless match
+
+            {
+              number: match[:number].to_i,
+              title: match[:title],
+              author: match[:author]
+            }
+          end
+        end
+
+        # Parse `fj issue view <ID>` output (same layout as PR view).
+        #
+        # @return [Hash, nil] {number:, title:, author:, state:}
+        def self.parse_issue_view(text)
+          parsed = parse_pr_view(text)
+          return nil unless parsed
+
+          parsed.slice(:number, :title, :author, :state)
+        end
+
+        # Parse `fj actions tasks` output into check evidence entries.
+        #
+        # Layout (minimal style):
+        #   #83 (fc14c43d36) success Complete package suite 23s (push): subject
+        #
+        # @return [Array<Hash>] {name:, state:, sha:}
+        def self.parse_actions_tasks(text)
+          text.to_s.lines.map { |line| clean(line) }.filter_map do |line|
+            match = line.match(
+              /\A#(?<task>\d+)\s+\((?<sha>[0-9a-f]+)\)\s+(?<state>\w+)\s+(?<name>.+?)\s+[\dhms.]+\s+\((?:push|pull_request|schedule)\)/
+            )
+            next nil unless match
+
+            {
+              name: match[:name],
+              state: match[:state].downcase.to_sym,
+              sha: match[:sha]
+            }
+          end
+        end
+
+        # Parse `fj repo view` output.
+        #
+        # @return [Hash] {full_name:, url:}
+        def self.parse_repo_view(text)
+          lines = text.to_s.lines.map { |line| clean(line) }.reject(&:empty?)
+          full_name = lines[0].to_s.empty? ? nil : lines[0]
+          url_line = lines.find { |line| line.start_with?("View online at") }
+          url = url_line && url_line.sub(/\AView online at\s+/, "")
+
+          {
+            full_name: full_name,
+            url: url
+          }
+        end
+
+        # Map `fj` state vocabulary onto the neutral state symbols.
+        def self.normalize_state(raw)
+          case raw.to_s.downcase
+          when "open" then :open
+          when "merged" then :merged
+          when "closed" then :closed
+          else raw.to_s.downcase.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/forgejo/pr_identifier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Forgejo
+      # Parse Forgejo pull request URL references into structured form.
+      #
+      # Supports the Forgejo-specific formats:
+      # - Simple number: "123"
+      # - Qualified reference: "owner/repo#456"
+      # - Forgejo URL: "https://forgejo.example.com/owner/repo/pulls/789"
+      module PrIdentifier
+        # Parsed identifier result. `forgejo_format` is the numeric form
+        # accepted by `fj pr` commands.
+        ParseResult = Data.define(:number, :repo, :forgejo_format)
+
+        MAX_IDENTIFIER_LENGTH = 256
+
+        def self.parse(input)
+          return nil if input.nil?
+
+          input_str = input.to_s.strip
+          return nil if input_str.empty?
+
+          if input_str.length > MAX_IDENTIFIER_LENGTH
+            raise ArgumentError, "PR identifier too long (max #{MAX_IDENTIFIER_LENGTH} characters)"
+          end
+
+          case input_str
+          when /\A(\d+)\z/
+            number = ::Regexp.last_match(1)
+            raise ArgumentError, "Invalid PR identifier format: #{input_str}" if number.to_i.zero?
+
+            canonical_number = number.to_i.to_s
+            ParseResult.new(number: canonical_number, repo: nil, forgejo_format: canonical_number)
+          when /\A(?<repo>[a-zA-Z0-9_\-.]+\/[a-zA-Z0-9_\-.]+)#(?<number>\d+)\z/
+            match = ::Regexp.last_match
+            ParseResult.new(number: match[:number], repo: match[:repo], forgejo_format: match[:number])
+          when %r{\Ahttps?://[^/]+/(?<repo>[^/]+/[^/]+)/pulls/(?<number>\d+)\z}i
+            match = ::Regexp.last_match
+            ParseResult.new(number: match[:number], repo: match[:repo], forgejo_format: match[:number])
+          else
+            raise ArgumentError, "Invalid PR identifier format: #{input_str}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/forgejo/provider.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require_relative "cli_executor"
+require_relative "parsers"
+
+module Ace
+  module Git
+    module Forgejo
+      # Forgejo provider implementation of the shared provider contract.
+      #
+      # Owns Forgejo terminology and translates `fj` responses into the
+      # normalized evidence types defined by the ace-git core. Every failure is
+      # classified with the shared taxonomy; `fj` failures are never hidden
+      # behind ad-hoc curl calls or silent fallbacks.
+      class Provider < Ace::Git::Providers::Base
+        class << self
+          def display_name
+            "Forgejo"
+          end
+        end
+
+        # @return [Boolean] true when the `fj` binary is installed
+        def available?
+          CliExecutor.installed?(runner: runner)
+        end
+
+        # @raise [Ace::Git::ProviderCliMissingError] when `fj` is missing
+        def check_available!
+          CliExecutor.check_installed!(runner: runner)
+        end
+
+        # @return [Boolean] true when the server host has a configured `fj` login
+        def authenticated?
+          CliExecutor.authenticated?(server_host, runner: runner)
+        end
+
+        # @raise [Ace::Git::ProviderAuthenticationError] when unauthenticated
+        def check_authenticated!
+          CliExecutor.check_authenticated!(host: server_host, runner: runner)
+        end
+
+        # @return [ProviderPullRequest] normalized pull request evidence
+        # @raise [ProviderObjectNotFoundError] when the PR does not exist
+        # @raise [ProviderMalformedOutputError] when `fj` output is unexpected
+        # @raise [ProviderUnreachableError] when the endpoint is unreachable
+        def pull_request(number:)
+          view = fj(["--style", "minimal", "pr", "view", number.to_s])
+          parsed = Parsers.parse_pr_view(view) ||
+            raise(Ace::Git::ProviderMalformedOutputError,
+              "Unrecognized `fj pr view #{number}` output; update the Forgejo provider parser")
+
+          parsed[:head_sha] = head_sha_of(number)
+          normalize_pr(parsed)
+        end
+
+        # @return [ProviderPullRequest, nil] evidence for the branch's PR
+        def pull_request_for_branch(branch:)
+          # `fj pr search` has no --limit flag; fetch all and order newest-first.
+          listing = fj(["--style", "minimal", "pr", "search", "--state", "all"])
+          entries = Parsers.parse_search(listing).sort_by { |entry| -entry[:number] }
+
+          entries.each do |entry|
+            view = fj(["--style", "minimal", "pr", "view", entry[:number].to_s])
+            parsed = Parsers.parse_pr_view(view)
+            next unless parsed && parsed[:head_ref] == branch
+
+            parsed[:head_sha] = head_sha_of(entry[:number])
+            return normalize_pr(parsed)
+          end
+
+          nil
+        end
+
+        # @return [String] unified diff text for the pull request
+        def pull_request_diff(number:)
+          fj(["pr", "view", number.to_s, "diff"])
+        end
+
+        # `fj pr search` has no --limit flag; cap client-side after sorting
+        # newest-first so the returned window is deterministic.
+        #
+        # @return [Array<ProviderPullRequest>] recent PRs, newest first
+        def recent_pull_requests(limit:)
+          listing = fj(["--style", "minimal", "pr", "search", "--state", "all"])
+          Parsers.parse_search(listing)
+            .map { |entry| normalize_search_entry(entry) }
+            .sort_by { |pr| -pr.number }
+            .first(limit)
+        end
+
+        # @return [ProviderIssue] normalized issue evidence
+        def issue(number:)
+          view = fj(["--style", "minimal", "issue", "view", number.to_s])
+          parsed = Parsers.parse_issue_view(view) ||
+            raise(Ace::Git::ProviderMalformedOutputError,
+              "Unrecognized `fj issue view #{number}` output; update the Forgejo provider parser")
+
+          Ace::Git::ProviderIssue.new(
+            server_name: server.name,
+            number: parsed[:number],
+            title: parsed[:title],
+            state: parsed[:state],
+            author: parsed[:author],
+            url: issue_url(parsed[:number]),
+            labels: nil
+          )
+        end
+
+        # @return [Array<ProviderCheck>] normalized check evidence for a ref
+        def checks(ref:)
+          tasks = fj(["--style", "minimal", "actions", "tasks"])
+          Parsers.parse_actions_tasks(tasks)
+            .select { |task| task[:sha].start_with?(ref.to_s) || ref.to_s.start_with?(task[:sha]) }
+            .map do |task|
+              Ace::Git::ProviderCheck.new(
+                server_name: server.name,
+                name: task[:name],
+                state: task[:state],
+                conclusion: task[:state],
+                url: nil
+              )
+            end
+        end
+
+        # @return [ProviderRepository] normalized repository evidence
+        def repository
+          view = fj(["--style", "minimal", "repo", "view"])
+          parsed = Parsers.parse_repo_view(view)
+
+          Ace::Git::ProviderRepository.new(
+            server_name: server.name,
+            full_name: parsed[:full_name],
+            default_branch: nil,
+            url: parsed[:url]
+          )
+        end
+
+        private
+
+        # Run one `fj` command, classifying every failure with the taxonomy.
+        def fj(args)
+          result = CliExecutor.execute(args, timeout: timeout, runner: runner)
+          return result[:stdout] if result[:success]
+
+          message = result[:stderr].to_s
+          case message
+          when /not found|does not exist|no pull request|no issue/i
+            raise Ace::Git::ProviderObjectNotFoundError, "Object not found (#{args.join(" ")}): #{message}"
+          when /access denied|unauthorized|token/i
+            raise Ace::Git::ProviderAuthenticationError, "Not authenticated with Forgejo: #{message}"
+          else
+            raise Ace::Git::ProviderUnreachableError, "Forgejo request failed (#{args.join(" ")}): #{message}"
+          end
+        end
+
+        def head_sha_of(number)
+          commits = fj(["--style", "minimal", "pr", "view", number.to_s, "commits"])
+          Parsers.parse_head_sha(commits)
+        end
+
+        def normalize_pr(parsed)
+          Ace::Git::ProviderPullRequest.new(
+            server_name: server.name,
+            number: parsed[:number],
+            title: parsed[:title],
+            state: parsed[:state],
+            head_ref: parsed[:head_ref],
+            base_ref: parsed[:base_ref],
+            head_sha: parsed[:head_sha],
+            author: parsed[:author],
+            url: pr_url(parsed[:number]),
+            draft: nil,
+            merged_at: nil
+          )
+        end
+
+        def normalize_search_entry(entry)
+          Ace::Git::ProviderPullRequest.new(
+            server_name: server.name,
+            number: entry[:number],
+            title: entry[:title],
+            state: nil,
+            head_ref: nil,
+            base_ref: nil,
+            head_sha: nil,
+            author: entry[:author],
+            url: pr_url(entry[:number]),
+            draft: nil,
+            merged_at: nil
+          )
+        end
+
+        def server_host
+          @server_host ||= begin
+            uri = URI.parse(server.url.to_s)
+            uri.host
+          rescue URI::Error
+            nil
+          end
+        end
+
+        def pr_url(number)
+          base = server.url.to_s.chomp("/")
+          "#{base}/pulls/#{number}"
+        end
+
+        def issue_url(number)
+          base = server.url.to_s.chomp("/")
+          "#{base}/issues/#{number}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/git/forgejo/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ace
+  module Git
+    module Forgejo
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/ace/git/forgejo.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "ace/git"
+
+require_relative "forgejo/version"
+require_relative "forgejo/cli_executor"
+require_relative "forgejo/pr_identifier"
+require_relative "forgejo/parsers"
+require_relative "forgejo/provider"
+
+module Ace
+  module Git
+    # Forgejo provider package for the forge-neutral ace-git core.
+    #
+    # Owns all Forgejo-specific behavior: `fj` CLI invocation, minimal-style
+    # output parsing, authentication verification, and Forgejo terminology.
+    # Implements the shared provider contract exposed by the core and
+    # registers itself in the core provider registry.
+    module Forgejo
+      PROVIDER_TYPE = :forgejo
+    end
+  end
+end
+
+Ace::Git::Providers.register(Ace::Git::Forgejo::PROVIDER_TYPE, Ace::Git::Forgejo::Provider)

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: ace-git-forgejo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michal Czyz
+bindir: exe
+cert_chain: []
+date: 2026-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ace-git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+description: 'Implements the shared ace-git provider contract for Forgejo: all `fj`
+  CLI invocation, output parsing, authentication verification, and classified failure
+  handling live behind one normalized evidence boundary. Ad-hoc curl fallbacks are
+  strictly excluded.'
+email:
+- mc@cs3b.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/ace/git/forgejo.rb
+- lib/ace/git/forgejo/cli_executor.rb
+- lib/ace/git/forgejo/parsers.rb
+- lib/ace/git/forgejo/pr_identifier.rb
+- lib/ace/git/forgejo/provider.rb
+- lib/ace/git/forgejo/version.rb
+homepage: https://forgejo.tail6c0887.ts.net/cs3b/ace
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://forgejo.tail6c0887.ts.net/cs3b/ace
+  source_code_uri: https://forgejo.tail6c0887.ts.net/cs3b/ace/src/branch/main/ace-git-forgejo
+  changelog_uri: https://forgejo.tail6c0887.ts.net/cs3b/ace/src/branch/main/ace-git-forgejo/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: 3.6.9
+specification_version: 4
+summary: Forgejo provider for the forge-neutral ace-git core
+test_files: []