Restore automated redirect checking in CI (removed in #3624)

[tpayet]

Follow-up to #3672.

#3624 removed the redirect-checking workflow on 2026-07-09 because it was "always broken". Four days later, #3542 shipped a navigation restructure that reintroduced a redirect bug (#3611), which had to be caught by hand and fixed in #3629. With no CI check, the next regression ships silently.

Given the SEO cost of redirect gaps documented in #3672 (the March restructure ran without complete redirects for 10 days to 3 weeks), some form of automated check is worth having again, even a minimal one. Suggestion for a more robust approach than the old script:

1. On every PR that touches config/navigation.json, config/redirects.json, or deletes/renames any .mdx file: verify that every previously reachable page path is either still present or has a source entry in config/redirects.json. This is a pure file diff against the base branch, no HTTP calls, so it cannot be flaky.
2. Verify every redirect destination in config/redirects.json resolves to an existing .mdx page path (or another redirect source, with cycle detection). Also pure file checks.
3. Optionally, a scheduled weekly job that curls a fixed list of high-traffic legacy URLs (top ~50 from GSC) and fails on anything that does not end in a 200.

Steps 1 and 2 would have caught both the March gap and the #3542 regression without the flakiness that got the old workflow deleted.

[jankvacek-cell]

@tpayet, here is a small offline starting point for #3675: check the union of previously reachable paths AND every current redirect source. That second set catches a newly added broken redirect even when its source was never a page.

The Python contract below has nine passing synthetic tests: unchanged page, deleted page without redirect, valid multi-hop chain, cycle, broken new redirect, duplicate source with conflicting destinations, external destination, page/redirect collision, and fragment destination. For example, old=/a, current=/c, redirects=/a→/b→/c passes; /a→/b→/a fails. External URLs and fragments are explicitly returned for policy review rather than silently treated as valid.

It uses only Python's standard library and makes no HTTP calls. The first integration step is an adapter that supplies normalized literal page paths and redirects from the PR base and head; this prototype does not parse your navigation/config files or model wildcard routes. The source and run instructions follow below. AI-assisted technical contribution, reviewed before sharing.

Free offline source and run instructions

Offline redirect contract

Run python redirect_contract.py using Python 3.
Nine synthetic tests pass locally. No packages, network, keys or project installation required.
Inputs: normalized literal internal paths and source/destination pairs. Base-path extraction, navigation parsing, MDX route mapping, wildcards and deployment behavior are not implemented. External URLs, queries and fragments require explicit integration policy.
This is an independent prototype, not tested against Meilisearch's repository. No SEO impact is measured.

"""Offline proposed redirect contract; no HTTP and no repository parser.
Inputs are normalized internal page paths. Not a Meilisearch integration.
"""
import unittest

def check(previous_paths, current_paths, redirects):
    pages = set(current_paths)
    routes = {}
    problems = []
    for source, destination in redirects:
        if source in routes and routes[source] != destination:
            problems.append((source, "CONFLICTING_DESTINATIONS"))
        routes[source] = destination
    for path in sorted(set(previous_paths) | set(routes)):
        node, seen = path, set()
        while True:
            if node in seen:
                problems.append((path, "CYCLE"))
                break
            seen.add(node)
            if not isinstance(node, str) or not node.startswith("/") or node.startswith("//"):
                problems.append((path, "UNSUPPORTED_TARGET"))
                break
            if "?" in node or "#" in node:
                problems.append((path, "QUERY_OR_FRAGMENT_REQUIRES_REVIEW"))
                break
            if node in pages and node in routes:
                problems.append((path, "PAGE_AND_REDIRECT_COLLISION"))
                break
            if node in pages:
                break
            if node not in routes:
                problems.append((path, "MISSING_DESTINATION"))
                break
            node = routes[node]
    return problems

class RedirectContractTests(unittest.TestCase):
    def test_unchanged(self):
        self.assertEqual(check(["/a"], ["/a"], []), [])
    def test_removed_page(self):
        self.assertIn(("/a", "MISSING_DESTINATION"), check(["/a"], [], []))
    def test_multihop(self):
        self.assertEqual(check(["/a"], ["/c"], [("/a","/b"),("/b","/c")]), [])
    def test_cycle(self):
        self.assertIn(("/a","CYCLE"), check(["/a"], [], [("/a","/b"),("/b","/a")]))
    def test_broken_new_redirect_is_checked(self):
        self.assertIn(("/new","MISSING_DESTINATION"), check([], [], [("/new","/absent")]))
    def test_duplicate_source(self):
        self.assertIn(("/a","CONFLICTING_DESTINATIONS"),
                      check(["/a"], ["/b","/c"], [("/a","/b"),("/a","/c")]))
    def test_external_requires_policy(self):
        self.assertIn(("/a","UNSUPPORTED_TARGET"), check(["/a"], [], [("/a","https://example.com")]))
    def test_page_redirect_collision(self):
        self.assertIn(("/a","PAGE_AND_REDIRECT_COLLISION"),check(["/a"],["/a","/b"],[("/a","/b")]))
    def test_anchor_requires_review(self):
        self.assertIn(("/a","QUERY_OR_FRAGMENT_REQUIRES_REVIEW"), check(["/a"],["/b"],[("/a","/b#x")]))

if __name__ == "__main__":
    unittest.main()