Skip to content
rlsbl.transition_record_followup
Updated
On this page

What a recorded conversion still owes the outside world: an unarchived absorb source, and an old Go module path that serves no deprecation notice.

#rlsbl.transition_record_followup

#rlsbl.transition_record_followup

What a recorded conversion still owes the outside world.

A transition record states what repository surgery DID; two of those facts imply an obligation that lives outside this repository, and nothing verifies them today:

  • an absorb leaves the source repository standing. Until it is archived it

keeps taking issues and pull requests, keeps appearing in searches, and keeps looking like the place to send a fix -- while the code moved here.

  • a go-module-path identity transition leaves the OLD module path

published. Until the old repository serves a // Deprecated: notice, every consumer resolving the old path gets a module with no sign that it moved.

Both checks are NETWORKED and both are fail-closed: an unanswered probe is a hard error, never a pass. "We could not ask" is not evidence that the source repo is archived or that the old module is deprecated, and reading it as such is how a check reports a clean bill of health for a repository nobody looked at.

Nothing here performs the remedy. rlsbl does not archive a repository it does not own the release cycle of, and it does not push a deprecation commit into a retired repo -- both findings print the exact command instead.

#FollowupVerdict

Findings, notes, and a skip reason for one transition-record-derived check.

#ok

python
def ok(self)

#absorbed_sources

python
def absorbed_sources(events)

[(github_slug_or_None, stated_repo)] for every absorb in events.

An extract's source is THIS repository, so only absorbs contribute: their source endpoint names a foreign repository that the absorb emptied.

#github_slug

python
def github_slug(repo)

owner/repo when repo names a github.com repository, else None.

A local path, a non-GitHub forge, and an SSH host alias (which names no host at all) each yield None: they are reported as unprobeable rather than assumed to be GitHub.

#go_module_transitions

python
def go_module_transitions(events)

[(old, new, effective_version)] for every go-module-path move.

#probe_repo_archived

python
def probe_repo_archived(slug, *, timeout=15)

Is the GitHub repository slug archived?

Returns {"status": "archived"}, {"status": "active"}, or {"status": "unknown", "message": ...}. Every unanswered probe -- a missing credential, a 404 that could equally be a deleted repo or a private one, a preview that recorded the call -- is "unknown", and the caller treats that as an error.

#_gh_error

python
def _gh_error(result)

The first meaningful line of gh's stderr.

#evaluate_old_repo_archived

python
def evaluate_old_repo_archived(events, *, probe=probe_repo_archived)

Every absorbed source repository should be archived.

#evaluate_go_deprecation_published

python
def evaluate_go_deprecation_published(events, *, probe=None)

Every superseded Go module path should serve a deprecation notice.

Search