Hardening from final review: scraper guards + test tightening

- extract-with-llm: guard against a non-array "sections" value (e.g. a
  string) so it takes the same empty-sections fallback path as
  missing/empty; rename the shadowing `empty?` binding to `no-sections?`
- parse-json-ld: return nil for a Recipe node with no (or blank) name,
  so it falls through to the LLM path instead of yielding a nil title
  that 500s on ScrapeResult response coercion
- extend llm-fallback-empty-sections-guard-test to cover both the
  empty-array and non-array "sections" payloads
- add json-ld-without-name-is-not-a-recipe-test for the nil-title guard
- assert the dropped-header warning text in
  header-ingredient-lines-trigger-grouping-test
- add an HTTP-level named-sections create/retrieve round-trip test

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ALai57

src/kaleidoscope/api/recipe_scraper.clj

@@ -201,19 +201,20 @@
        vec))
 
 (defn parse-json-ld
-  "Extract verbatim recipe facts from JSON-LD, or nil if no Recipe found.
-  Facts, not a draft: `scrape` decides how facts become sections."
+  "Extract verbatim recipe facts from JSON-LD, or nil if no Recipe (or none with
+  a name) found. Facts, not a draft: `scrape` decides how facts become sections."
   [html]
   (when-let [node (find-recipe-node (ld-json-blocks html))]
-    (let [{:keys [steps section-names]} (parse-instructions (:recipeInstructions node))]
-      {:title             (:name node)
-       :ingredients       (vec (:recipeIngredient node))
-       :steps             steps
-       :section-names     section-names
-       :servings          (some-> (first-or-self (:recipeYield node)) str)
-       :prep-time-minutes (iso-duration->minutes (:prepTime node))
-       :cook-time-minutes (iso-duration->minutes (:cookTime node))
-       :suggested-labels  (->suggested-labels node)})))
+    (when-not (str/blank? (:name node))
+      (let [{:keys [steps section-names]} (parse-instructions (:recipeInstructions node))]
+        {:title             (:name node)
+         :ingredients       (vec (:recipeIngredient node))
+         :steps             steps
+         :section-names     section-names
+         :servings          (some-> (first-or-self (:recipeYield node)) str)
+         :prep-time-minutes (iso-duration->minutes (:prepTime node))
+         :cook-time-minutes (iso-duration->minutes (:cookTime node))
+         :suggested-labels  (->suggested-labels node)}))))
 
 (defn- single-section
   [{:keys [ingredients steps]}]
@@ -342,22 +343,24 @@
                    :messages   [{:role "user" :content text}]})
         raw      (-> response :content first :text)
         parsed   (json/decode (llm/extract-json raw) true)]
-    (let [sections (mapv (fn [{:keys [name ingredients steps]}]
-                           {:name        name
-                            :ingredients (vec ingredients)
-                            :steps       (vec steps)})
-                         (:sections parsed))
-          empty?   (empty? sections)]
+    (let [raw-sections (:sections parsed)
+          sections     (when (sequential? raw-sections)
+                         (mapv (fn [{:keys [name ingredients steps]}]
+                                 {:name        name
+                                  :ingredients (vec ingredients)
+                                  :steps       (vec steps)})
+                               raw-sections))
+          no-sections? (empty? sections)]
       {:recipe {:title             (:title parsed)
-                :sections          (if empty?
+                :sections          (if no-sections?
                                      [{:name nil :ingredients [] :steps []}]
                                      sections)
                 :servings          (:servings parsed)
                 :prep-time-minutes (:prep_time_minutes parsed)
                 :cook-time-minutes (:cook_time_minutes parsed)}
        :suggested-labels  (vec (:suggested_labels parsed))
        :extraction-method "llm"
-       :warnings          (if empty? ["LLM returned no sections"] [])})))
+       :warnings          (if no-sections? ["LLM returned no sections"] [])})))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Entry point

test/kaleidoscope/api/recipe_scraper_test.clj

@@ -79,6 +79,10 @@
     (is (nil? (scraper/parse-json-ld "<html><body>just a blog</body></html>")))
     (is (nil? (scraper/parse-json-ld "<script type='application/ld+json'>{not valid json</script>")))))
 
+(deftest json-ld-without-name-is-not-a-recipe-test
+  (testing "a Recipe node with no name yields nil facts — falls through to the LLM path"
+    (is (nil? (scraper/parse-json-ld "<script type='application/ld+json'>{\"@type\":\"Recipe\",\"recipeIngredient\":[\"salt\"],\"recipeInstructions\":\"Mix\"}</script>")))))
+
 (deftest ssrf-rejection-test
   (testing "loopback, private, link-local, metadata, and non-http schemes are rejected"
     (is (match? {:reason :blocked-url}
@@ -114,13 +118,14 @@
                   (scraper/scrape {:api-key "sk-test"} "http://example.com/stew"))))))
 
 (deftest llm-fallback-empty-sections-guard-test
-  (testing "an LLM response with no sections still satisfies the min-1-section shape"
-    (with-redefs [scraper/fetch-direct (fn [_] "<html><body>vague food blog</body></html>")
-                  llm/post-anthropic-sync
-                  (fn [_ _] {:content [{:text "{\"title\":\"Mystery\",\"sections\":[],\"suggested_labels\":[]}"}]})]
-      (is (match? {:recipe {:title "Mystery" :sections [{:ingredients [] :steps []}]}
-                   :warnings [#"no sections"]}
-                  (scraper/scrape {:api-key "sk-test"} "http://example.com/mystery"))))))
+  (testing "an LLM response with no (or non-array) sections still satisfies the min-1-section shape"
+    (doseq [sections-json ["\"sections\":[]" "\"sections\":\"none\""]]
+      (with-redefs [scraper/fetch-direct (fn [_] "<html><body>vague food blog</body></html>")
+                    llm/post-anthropic-sync
+                    (fn [_ _] {:content [{:text (str "{\"title\":\"Mystery\"," sections-json ",\"suggested_labels\":[]}")}]})]
+        (is (match? {:recipe {:title "Mystery" :sections [{:ingredients [] :steps []}]}
+                     :warnings [#"no sections"]}
+                    (scraper/scrape {:api-key "sk-test"} "http://example.com/mystery")))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Bot-block fallback to the rendering fetcher
@@ -203,7 +208,8 @@
                     llm/post-anthropic-sync (fn [_ _] {:content [{:text grouping}]})]
         (is (match? {:recipe {:sections [{:name "Cake"     :ingredients ["2 cups flour"]  :steps ["Mix"]}
                                          {:name "Frosting" :ingredients ["1 cup butter"] :steps ["Whip"]}]}
-                     :extraction-method "json-ld+llm-sections"}
+                     :extraction-method "json-ld+llm-sections"
+                     :warnings          [#"For the cake:.*For the frosting:"]}
                     (scraper/scrape {:api-key "sk-test"} public-url)))))))
 
 (deftest sectioned-without-api-key-flattens-with-warning-test

test/kaleidoscope/http_api/recipes_test.clj

@@ -162,3 +162,19 @@
                              as-writer
                              (mock/json-body (assoc example-body
                                                     :label-ids [(:id l1) (:id l2)]))))))))))
+
+(deftest named-sections-round-trip-http-test
+  (let [app  (make-app "custom-authenticated-user")
+        body {:content {:title    "Layer Cake"
+                        :sections [{:name "Cake" :ingredients ["2 cups flour"] :steps ["Mix" "Bake"]}
+                                   {:name "Frosting" :ingredients ["1 cup butter"] :steps ["Whip"]}]}
+              :public-visibility true}]
+    (testing "named sections survive create → retrieve through the router"
+      (is (match? {:status 200 :body {:recipe-url "layer-cake"}}
+                  (app (-> (mock/request :post "https://andrewslai.com/recipes")
+                           as-writer
+                           (mock/json-body body)))))
+      (is (match? {:status 200
+                   :body   {:content {:sections [{:name "Cake" :ingredients ["2 cups flour"] :steps ["Mix" "Bake"]}
+                                                 {:name "Frosting" :ingredients ["1 cup butter"] :steps ["Whip"]}]}}}
+                  (app (mock/request :get "https://andrewslai.com/recipes/layer-cake")))))))