feat(frameworks): Yesod detection + pattern set (WI-vabiv / UAT BUG-16)

UAT-2026-04-13 BUG-16 flagged Yesod (Haskell web framework, the
Rails-inspired one used by haskellers) as missing from framework
detection. The three other frameworks named in the tracker item
(http4s, play, flask-appbuilder) already had YAML patterns in the
repo — Yesod was the only genuine gap.

Two pieces:

1. Detection: `HASKELL_FRAMEWORKS["yesod"] = ["yesod", "yesod-core",
   "yesod-auth", "yesod-persistent"]` in profile.py picks Yesod up
   from *.cabal build-depends, package.yaml hpack deps, and
   stack.yaml extra-deps — same plumbing Servant and Scotty already
   use.

2. Pattern set: new frameworks/yesod.yaml covering Yesod's
   conventions since Template Haskell quasi-quoters like
   `[parseRoutes| ... |]` aren't statically parseable by
   hypergumbo.  Instead we match the stable conventions:

   - `mkYesod` / `mkYesodData` / `mkYesodSubData` /
     `mkYesodSubDispatch` / `parseRoutes` quasi-quoter calls
     (concept=application / router).
   - Warp runner calls: `warp`, `warpEnv`, `warpDebug`, `warpTLS`,
     `toWaiApp`, `toWaiAppPlain` (concept=application).
   - `Yesod` / `YesodSubsite` / `YesodSubDispatch` base_class
     matches (concept=application).
   - `RenderRoute` / `ParseRoute` router-class memberships.
   - `YesodPersist` / `YesodAuth` / `YesodBreadcrumbs` standard
     mixins (concept=database / auth).
   - Handler naming convention: function-kind symbols whose names
     match `^(get|post|put|delete|patch|head|options)[A-Z]...R$`
     get concept=route. These ARE the Yesod routes — the
     TH-generated dispatcher calls them by name. HTTP-method
     extraction for everything past GET/POST is a later
     materializer expansion; for now the concept attachment is
     enough to recognize the handlers downstream.
   - `Handler` / `HandlerFor` / `HandlerT` / `HandlerM` monad type
     membership (concept=route).
   - `Widget` components, `YForm` / `MForm` / `AForm` forms,
     `PersistEntity` models.

3 tests:
- Detection from *.cabal
- Detection from package.yaml
- yesod.yaml loads via load_framework_patterns with the expected
  concept set ({application, router, route, auth, model, ...})
  so typos / schema drift in the YAML fail fast.

Signed-off-by: jgstern-agent <josh-agent@iterabloom.com>

Author: jgstern-agent

.ci/affected-tests.txt

@@ -1,15 +1,16 @@
 # Test selection manifest
-# Generated by smart-test at 2026-04-15T08:49:45-04:00
+# Generated by smart-test at 2026-04-15T09:17:20-04:00
 # Mode: targeted
 # Baseline: 02dba9744d2c86e26f06565aad4ebcae7ef0f4a8
-# Changed files: 31
-# Changed source files: 6
-# Selected tests: 65
+# Changed files: 35
+# Changed source files: 7
+# Selected tests: 66
 #
 # === CHANGED_SOURCE_FILES ===
 packages/hypergumbo-core/src/hypergumbo_core/cli.py
 packages/hypergumbo-core/src/hypergumbo_core/_hf_noise.py
 packages/hypergumbo-core/src/hypergumbo_core/io_boundary.py
+packages/hypergumbo-core/src/hypergumbo_core/profile.py
 packages/hypergumbo-core/src/hypergumbo_core/sketch_embeddings.py
 packages/hypergumbo-lang-mainstream/src/hypergumbo_lang_mainstream/php.py
 packages/hypergumbo-tracker/src/hypergumbo_tracker/cli.py
@@ -37,6 +38,7 @@ packages/hypergumbo-core/tests/test_io_boundary.py
 packages/hypergumbo-core/tests/test_locale.py
 packages/hypergumbo-core/tests/test_max_tier.py
 packages/hypergumbo-core/tests/test_no_first_party_priority.py
+packages/hypergumbo-core/tests/test_partial_install_warnings.py
 packages/hypergumbo-core/tests/test_profile.py
 packages/hypergumbo-core/tests/test_pyffi_linker.py
 packages/hypergumbo-core/tests/test_rubyffi_linker.py

CHANGELOG.md

@@ -12,6 +12,7 @@ This changelog tracks the **tool version** (package releases). The **schema vers
 
 ### Added
 
+- **Yesod framework detection + pattern set** (WI-vabiv / UAT BUG-16): Yesod (Haskell — haskellers) is now detected from `*.cabal` / `package.yaml` dependencies (`yesod`, `yesod-core`, `yesod-auth`, `yesod-persistent`) and a new `frameworks/yesod.yaml` ships patterns for the Yesod conventions: `mkYesod` / `mkYesodData` / `mkYesodSubData` / `parseRoutes` quasi-quoter calls, Warp runner (`warp`/`warpTLS`/`toWaiApp`), `Yesod` / `YesodSubsite` typeclass memberships, `RenderRoute` / `ParseRoute` router class, standard mixin typeclasses (`YesodPersist`, `YesodAuth`, `YesodBreadcrumbs`), and the `<method><Resource>R` handler naming convention (getHomeR, postUserR, deleteUserR, ...). Route materialization for the non-GET/non-POST methods is a later materializer expansion; concepts are attached today so downstream analysis recognizes the handlers as web-handler entry points.
 - **Elixir I/O primitive catalog** (WI-vibur / UAT BUG-09b): new `io_primitives/elixir.yaml` fixes the "0 boundaries on plausible (Phoenix/Ecto)" gap. Covers Elixir stdlib (`File.read`/`write`/`stream!`, `IO.puts`/`write`/`read`, `System.cmd`/`get_env`, `Logger.*`), the idiomatic HTTP-client galaxy (`HTTPoison`, `Tesla`, `Req`, `Finch`, `Mint.HTTP*`, plus Erlang `:httpc`), Phoenix server surface (`Phoenix.Router.get/post/...`, `Phoenix.Controller.render/json`, `Plug.Conn.send_resp/read_body`, `Phoenix.Channel.broadcast`, `Phoenix.Endpoint.broadcast`), databases (Ecto.Repo read/write verbs, `Ecto.Multi`, `Postgrex.query`, `MyXQL.query`, `Redix.command`), and IPC (`GenServer.call/cast`, `Process.send`, `Oban.insert`, `Task.async`). `elixir` added to `_CATALOG_PARENTS` with `erlang` as parent so atom-access into Erlang (`:gen_tcp.send`, `:ets.lookup`, `:file.read_file`) is still matched. Elixir-specific `ambiguous_names` prevents Elixir pipe/Enum verbs and scope functions from producing short-name false positives.
 - **Kotlin I/O primitive catalog** (WI-rujos / UAT BUG-09d): new `io_primitives/kotlin.yaml` with Kotlin-specific entries. Kotlin was previously aliased to `java.yaml` verbatim via `_CATALOG_ALIASES`, which produced only 1 boundary (net_send) on detekt because Kotlin idiom uses extension functions and top-level stdlib functions that have no Java analog. The new catalog covers: `kotlin.io` File extensions (`readText`, `writeText`, `forEachLine`, `useLines`, `copyTo`, `walk`), `kotlin.io.path` Path extensions (Kotlin 1.5+), top-level `println`/`print` (receiver `kotlin.io.ConsoleKt`), ktor client + server, `android.util.Log`, `kotlin-logging` (`mu.KLogger` and the 5.x relocated `io.github.oshai.kotlinlogging.KLogger`), and Exposed ORM read/write. Kotlin-specific `ambiguous_names` prevent scope functions (`apply`, `run`, `let`, `use`) and coroutine/Flow verbs (`send`, `receive`, `collect`) from producing short-name false positives. `kotlin` moved from `_CATALOG_ALIASES` to `_CATALOG_PARENTS` so the Java parent still provides the raw `java.io/java.net/JDBC/SLF4J` entries for Kotlin code that uses those APIs directly.
 

packages/hypergumbo-core/src/hypergumbo_core/frameworks/yesod.yaml

@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Yesod framework patterns (ADR-0003)
+#
+# Yesod is a Rails-inspired web framework for Haskell. Route registration
+# happens in a Template Haskell quasi-quoter (`parseRoutes`) that hypergumbo
+# can't fully evaluate, so detection falls back to the stable conventions
+# Yesod enforces on handler naming and typeclass membership:
+#
+# - Every route handler is named `<method><Resource>R` with the method
+#   lowercase and the resource capitalized, and has kind=function.
+#   Examples: getHomeR, postUserR, getUserR, deleteUserR, putBookR.
+# - Yesod applications implement the `Yesod` typeclass; subsites
+#   implement `YesodSubsite`.
+# - Route types derive `RenderRoute` / `ParseRoute`.
+# - Convention: quasi-quoter declarations via `mkYesod` or `mkYesodData`.
+#
+# UAT-2026-04-13 BUG-16 flagged the gap on haskellers. WI-vabiv.
+
+id: yesod
+language: haskell
+
+patterns:
+  # ==================== USAGE-BASED PATTERNS (v1.1.x) ====================
+  # mkYesod "App" [parseRoutes| ... |] — declares the route table.
+  # We can't parse the inside of the quasi-quoter without TH evaluation,
+  # but detecting the mkYesod call itself identifies the app root.
+  - concept: application
+    usage:
+      kind: "^call$"
+      name: "^mkYesod$"
+
+  # mkYesodData for declaring route data type separately
+  - concept: application
+    usage:
+      kind: "^call$"
+      name: "^mkYesodData$"
+
+  # mkYesodSubData / mkYesodSubDispatch — subsite boundaries
+  - concept: application
+    usage:
+      kind: "^call$"
+      name: "^(mkYesodSubData|mkYesodSubDispatch)$"
+
+  # parseRoutes quasi-quoter call (some projects use it directly)
+  - concept: router
+    usage:
+      kind: "^call$"
+      name: "^parseRoutes$"
+
+  # Warp runner — what actually serves the app (common Yesod pattern:
+  # `warpEnv . toWaiAppPlain`, `warp 3000 app`).
+  - concept: application
+    usage:
+      kind: "^call$"
+      name: "^(warp|warpEnv|warpDebug|warpTLS|toWaiApp|toWaiAppPlain)$"
+
+  # ==================== DEFINITION-BASED PATTERNS (v1.0.x) ====================
+
+  # Yesod typeclass instance — marks the app root type
+  - concept: application
+    base_class: "^Yesod$"
+
+  # YesodSubsite / YesodSubDispatch — subsite class memberships
+  - concept: application
+    base_class: "^(YesodSubsite|YesodSubDispatch)$"
+
+  # RenderRoute / ParseRoute — route-type typeclass membership
+  - concept: router
+    base_class: "^(RenderRoute|ParseRoute)$"
+
+  # YesodPersist / YesodAuth / YesodBreadcrumbs — standard mixin typeclasses
+  # covering the common Yesod extension surface
+  - concept: database
+    base_class: "^YesodPersist$"
+
+  - concept: auth
+    base_class: "^YesodAuth$"
+
+  # Handler naming convention — function-kind symbols whose names match
+  # the <method><Resource>R pattern. These ARE the Yesod routes: the
+  # framework's TH-generated dispatcher calls them by name, so the
+  # handler function IS the route entry.
+  #
+  # Notes on HTTP method: Yesod encodes the method in the prefix
+  # (getHomeR → GET /home). The current route materializer applies
+  # the get-prefix convention for GET and do-prefix for POST; other
+  # methods (post/put/delete/patch/head/options) attach the concept
+  # but don't yet materialize a route symbol with an HTTP method.
+  # That's a materializer expansion for a later item — these patterns
+  # still enrich symbols with concept=route so downstream analysis
+  # recognizes them as web-handler entry points.
+  - concept: route
+    symbol_name: "^getR$|^get[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  - concept: route
+    symbol_name: "^postR$|^post[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  - concept: route
+    symbol_name: "^putR$|^put[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  - concept: route
+    symbol_name: "^deleteR$|^delete[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  - concept: route
+    symbol_name: "^patchR$|^patch[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  - concept: route
+    symbol_name: "^headR$|^head[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  - concept: route
+    symbol_name: "^optionsR$|^options[A-Z][A-Za-z0-9_']*R$"
+    symbol_kind: "^function$"
+
+  # Handler type signatures (some projects declare explicit Handler types)
+  - concept: route
+    base_class: "^Handler$"
+
+  # Widgets — Yesod-style reusable UI fragments
+  - concept: component
+    base_class: "^Widget$"
+
+  # Form declarations — YForm / MForm / AForm
+  - concept: form
+    base_class: "^(YForm|MForm|AForm)$"
+
+  # Persistent (database) typeclass — common pairing with Yesod
+  - concept: model
+    base_class: "^PersistEntity$"
+
+  # HandlerFor / HandlerM — Yesod monad type aliases.  Not all projects
+  # use these as base classes, but matching catches the ones that do.
+  - concept: route
+    base_class: "^(HandlerFor|HandlerT|HandlerM)$"
+
+linkers:
+  - http

packages/hypergumbo-core/src/hypergumbo_core/profile.py

@@ -393,6 +393,8 @@
 HASKELL_FRAMEWORKS = {
     "servant": ["servant", "servant-server"],
     "scotty": ["scotty"],
+    # Yesod — Rails-inspired Haskell web framework (haskellers et al.)
+    "yesod": ["yesod", "yesod-core", "yesod-auth", "yesod-persistent"],
 }
 
 # Clojure framework detection patterns (from deps.edn, project.clj)

packages/hypergumbo-core/tests/test_profile.py

@@ -1661,6 +1661,66 @@ def test_detects_haskell_servant_from_package_yaml(tmp_path: Path) -> None:
     assert "servant" in data["profile"]["frameworks"]
 
 
+def test_detects_haskell_yesod_framework_from_cabal(tmp_path: Path) -> None:
+    """WI-vabiv: detect Yesod from *.cabal dependency.
+
+    Yesod (UAT BUG-16 / haskellers) is the Rails-inspired Haskell web
+    framework; detection wires it up like Servant / Scotty so the new
+    yesod.yaml patterns are loaded when a repo declares the dependency.
+    """
+    (tmp_path / "Main.hs").write_text("main = putStrLn \"Hello\"\n")
+    (tmp_path / "myapp.cabal").write_text("""name: myapp
+version: 0.1.0.0
+build-depends:
+    base >=4.7 && <5,
+    yesod,
+    yesod-core,
+    yesod-auth
+""")
+
+    out_path = tmp_path / "out.json"
+    run_behavior_map(repo_root=tmp_path, out_path=out_path, include_sketch_precomputed=False)
+
+    data = json.loads(out_path.read_text())
+    assert "yesod" in data["profile"]["frameworks"]
+
+
+def test_detects_haskell_yesod_from_package_yaml(tmp_path: Path) -> None:
+    """WI-vabiv: detect Yesod from package.yaml (hpack)."""
+    (tmp_path / "Main.hs").write_text("main = putStrLn \"Hello\"\n")
+    (tmp_path / "package.yaml").write_text("""name: myapp
+dependencies:
+  - base >= 4.7 && < 5
+  - yesod
+  - yesod-persistent
+""")
+
+    out_path = tmp_path / "out.json"
+    run_behavior_map(repo_root=tmp_path, out_path=out_path, include_sketch_precomputed=False)
+
+    data = json.loads(out_path.read_text())
+    assert "yesod" in data["profile"]["frameworks"]
+
+
+def test_yesod_framework_yaml_loads(tmp_path: Path) -> None:
+    """WI-vabiv: yesod.yaml loads via load_framework_patterns and declares
+    the expected concepts (application, router, route, auth, model, etc.).
+    Guards against typos or schema drift in the new file.
+    """
+    from hypergumbo_core.framework_patterns import load_framework_patterns
+
+    pattern_def = load_framework_patterns("yesod")
+    assert pattern_def is not None, "yesod.yaml must load"
+    assert pattern_def.id == "yesod"
+    assert pattern_def.language == "haskell"
+
+    concepts = {p.concept for p in pattern_def.patterns}
+    for required in ("application", "router", "route", "auth", "model"):
+        assert required in concepts, (
+            f"yesod pattern set missing concept: {required}"
+        )
+
+
 # Clojure framework detection tests