From 2afe840edee2af591d55be73797dd23132a26027 Mon Sep 17 00:00:00 2001
From: ganome <ganome@gmail.com>
Date: Thu, 4 Dec 2025 18:34:35 -0700
Subject: [PATCH] Initial Commit

---
 Makefile          |  13 ++
 gscrape           | Bin 0 -> 36984 bytes
 include/scraper.h |  33 +++
 src/main.c        | 217 +++++++++++++++++++
 src/scraper.c     | 520 ++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 783 insertions(+)
 create mode 100644 Makefile
 create mode 100755 gscrape
 create mode 100644 include/scraper.h
 create mode 100644 src/main.c
 create mode 100644 src/scraper.c

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..7349ef0
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,13 @@
+CC=gcc
+CFLAGS=-Iinclude -Wall $(shell pkg-config --cflags libxml-2.0 libcurl)
+LDFLAGS=$(shell pkg-config --libs libxml-2.0 libcurl)
+SRCS=src/main.c src/scraper.c
+TARGET=gscrape
+
+all: $(TARGET)
+
+$(TARGET): $(SRCS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+clean:
+	rm -f $(TARGET) *.o src/*.o
diff --git a/gscrape b/gscrape
new file mode 100755
index 0000000000000000000000000000000000000000..f6ecf0cc823d10d69b4b6b478906338bb98f8fc7
GIT binary patch
literal 36984
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
V6?7a<#>zkPT_JIdErTto{U3V^cS!&M

literal 0
HcmV?d00001

diff --git a/include/scraper.h b/include/scraper.h
new file mode 100644
index 0000000..88d23be
--- /dev/null
+++ b/include/scraper.h
@@ -0,0 +1,33 @@
+#ifndef SCRAPER_H
+#define SCRAPER_H
+
+#include <stdlib.h>
+
+int fetch_url(const char *url, char **out_buf, size_t *out_len);
+char *extract_title(const char *html, size_t len);
+
+/* Extract all <meta name=... content=...> and <meta property=... content=...>
+ * Returns 0 on success and allocates *out with a newline-separated list
+ * of "key: value" lines. Caller must free(*out).
+ */
+int extract_meta(const char *html, size_t len, char **out);
+
+/* Extract Open Graph tags (meta property="og:...") similarly. */
+int extract_og(const char *html, size_t len, char **out);
+
+/* Extract the first <script type="application/ld+json"> that looks like a
+ * Product schema. Returns 0 and allocates *out_json (caller frees) or
+ * returns -1 if not found.
+ */
+int extract_jsonld_product(const char *html, size_t len, char **out_json);
+
+/* Extract the text content of the first <h1> element, or NULL if none. */
+char *extract_h1(const char *html, size_t len);
+
+/* Extract product listings (one per line) as "name | price | url".
+ * Returns 0 and allocates *out on success (caller frees), or -1.
+ * Each line represents one product; fields are separated by '|'.
+ */
+int extract_products(const char *html, size_t len, char **out);
+
+#endif /* SCRAPER_H */
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..f0132bc
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,217 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "scraper.h"
+#include <string.h>
+
+static char *json_escape(const char *s) {
+    if (!s) return strdup("\"\"");
+    size_t len = strlen(s);
+    size_t cap = len * 2 + 3;
+    char *out = malloc(cap);
+    if (!out) return NULL;
+    size_t oi = 0;
+    out[oi++] = '"';
+    for (size_t i = 0; i < len; ++i) {
+        unsigned char c = s[i];
+        if (c == '"' || c == '\\') {
+            if (oi + 2 >= cap) { cap *= 2; out = realloc(out, cap); }
+            out[oi++] = '\\';
+            out[oi++] = c;
+        } else if (c == '\b') { if (oi + 2 >= cap) { cap *= 2; out = realloc(out, cap); } out[oi++] = '\\'; out[oi++] = 'b'; }
+        else if (c == '\f') { if (oi + 2 >= cap) { cap *= 2; out = realloc(out, cap); } out[oi++] = '\\'; out[oi++] = 'f'; }
+        else if (c == '\n') { if (oi + 2 >= cap) { cap *= 2; out = realloc(out, cap); } out[oi++] = '\\'; out[oi++] = 'n'; }
+        else if (c == '\r') { if (oi + 2 >= cap) { cap *= 2; out = realloc(out, cap); } out[oi++] = '\\'; out[oi++] = 'r'; }
+        else if (c == '\t') { if (oi + 2 >= cap) { cap *= 2; out = realloc(out, cap); } out[oi++] = '\\'; out[oi++] = 't'; }
+        else if (c < 0x20) {
+            char buf[7]; snprintf(buf, sizeof(buf), "\\u%04x", c);
+            size_t bl = strlen(buf);
+            if (oi + bl + 1 >= cap) { cap = cap + bl + 16; out = realloc(out, cap); }
+            memcpy(out + oi, buf, bl); oi += bl;
+        } else {
+            if (oi + 1 >= cap) { cap *= 2; out = realloc(out, cap); }
+            out[oi++] = c;
+        }
+    }
+    if (oi + 2 >= cap) { cap += 2; out = realloc(out, cap); }
+    out[oi++] = '"';
+    out[oi] = '\0';
+    return out;
+}
+
+static void print_kv_json(const char *kv_lines) {
+    if (!kv_lines) { printf("null"); return; }
+    printf("{");
+    const char *p = kv_lines;
+    int first = 1;
+    while (*p) {
+        const char *line_end = strchr(p, '\n');
+        size_t linelen = line_end ? (size_t)(line_end - p) : strlen(p);
+        if (linelen > 0) {
+            const char *sep = memchr(p, ':', linelen);
+            if (sep) {
+                size_t keylen = (size_t)(sep - p);
+                const char *vstart = sep + 1;
+                while (vstart < p + linelen && (*vstart == ' ' || *vstart == '\t')) vstart++;
+                size_t vallen = (p + linelen) - vstart;
+                char *key = malloc(keylen + 1);
+                char *val = malloc(vallen + 1);
+                memcpy(key, p, keylen); key[keylen] = '\0';
+                memcpy(val, vstart, vallen); val[vallen] = '\0';
+                char *ek = json_escape(key);
+                char *ev = json_escape(val);
+                free(key); free(val);
+                if (!first) printf(",");
+                first = 0;
+                printf("%s:%s", ek, ev);
+                free(ek); free(ev);
+            }
+        }
+        if (!line_end) break;
+        p = line_end + 1;
+    }
+    printf("}");
+}
+
+static void print_products_json(const char *products_lines) {
+    if (!products_lines) { printf("null"); return; }
+    printf("[");
+    const char *p = products_lines;
+    int first = 1;
+    while (*p) {
+        const char *line_end = strchr(p, '\n');
+        size_t linelen = line_end ? (size_t)(line_end - p) : strlen(p);
+        if (linelen > 0) {
+            /* expect: name | price | url */
+            const char *s1 = memchr(p, '|', linelen);
+            const char *s2 = s1 ? memchr(s1 + 1, '|', (size_t)(p + linelen - (s1 + 1))) : NULL;
+            char *name = NULL; char *price = NULL; char *url = NULL;
+            if (s1 && s2) {
+                size_t nlen = (size_t)(s1 - p);
+                const char *p2 = s1 + 1;
+                while (nlen > 0 && (p[nlen-1] == ' ' || p[nlen-1] == '\t')) nlen--;
+                while (p2 < s2 && (*p2 == ' ' || *p2 == '\t')) p2++;
+                size_t plen = (size_t)(s2 - p2);
+                const char *u2 = s2 + 1;
+                while (u2 < p + linelen && (*u2 == ' ' || *u2 == '\t')) u2++;
+                size_t ulen = (p + linelen) - u2;
+                name = malloc(nlen + 1); memcpy(name, p, nlen); name[nlen] = '\0';
+                price = malloc(plen + 1); memcpy(price, p2, plen); price[plen] = '\0';
+                url = malloc(ulen + 1); memcpy(url, u2, ulen); url[ulen] = '\0';
+            } else if (s1) {
+                /* only name|price */
+                size_t nlen = (size_t)(s1 - p);
+                const char *p2 = s1 + 1;
+                while (nlen > 0 && (p[nlen-1] == ' ' || p[nlen-1] == '\t')) nlen--;
+                while (p2 < p + linelen && (*p2 == ' ' || *p2 == '\t')) p2++;
+                size_t plen = (p + linelen) - p2;
+                name = malloc(nlen + 1); memcpy(name, p, nlen); name[nlen] = '\0';
+                price = malloc(plen + 1); memcpy(price, p2, plen); price[plen] = '\0';
+                url = strdup("");
+            } else {
+                /* fallback whole line as name */
+                name = malloc(linelen + 1); memcpy(name, p, linelen); name[linelen] = '\0';
+                price = strdup("");
+                url = strdup("");
+            }
+            char *en = json_escape(name);
+            char *ep = json_escape(price);
+            char *eu = json_escape(url);
+            free(name); free(price); free(url);
+            if (!first) printf(",");
+            first = 0;
+            printf("{\"name\":%s,\"price\":%s,\"url\":%s}", en, ep, eu);
+            free(en); free(ep); free(eu);
+        }
+        if (!line_end) break;
+        p = line_end + 1;
+    }
+    printf("]");
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2) {
+        fprintf(stderr, "Usage: %s <url>\n", argv[0]);
+        return 2;
+    }
+
+    const char *url = argv[1];
+    char *html = NULL;
+    size_t html_len = 0;
+
+    if (fetch_url(url, &html, &html_len) != 0) {
+        fprintf(stderr, "Failed to fetch URL: %s\n", url);
+        return 1;
+    }
+
+    char *title = extract_title(html, html_len);
+    /* Output JSON */
+    printf("{");
+    /* url */
+    char *eurl = json_escape(url);
+    printf("\"url\":%s,", eurl); free(eurl);
+
+    /* title */
+    if (title) {
+        char *et = json_escape(title);
+        printf("\"title\":%s,", et);
+        free(et);
+        free(title);
+    } else {
+        printf("\"title\":null,");
+    }
+
+    char *h1 = extract_h1(html, html_len);
+    if (h1) {
+        char *eh1 = json_escape(h1);
+        printf("\"h1\":%s,", eh1);
+        free(eh1);
+        free(h1);
+    } else {
+        printf("\"h1\":null,");
+    }
+
+    char *meta = NULL;
+    if (extract_meta(html, html_len, &meta) == 0 && meta) {
+        printf("\"meta\":");
+        print_kv_json(meta);
+        printf(",");
+        free(meta);
+    } else {
+        printf("\"meta\":null,");
+    }
+
+    char *og = NULL;
+    if (extract_og(html, html_len, &og) == 0 && og) {
+        printf("\"og\":");
+        print_kv_json(og);
+        printf(",");
+        free(og);
+    } else {
+        printf("\"og\":null,");
+    }
+
+    char *jsonld = NULL;
+    if (extract_jsonld_product(html, html_len, &jsonld) == 0 && jsonld) {
+        /* include raw JSON-LD as string */
+        char *ej = json_escape(jsonld);
+        printf("\"jsonld_product\":%s,", ej);
+        free(ej);
+        free(jsonld);
+    } else {
+        printf("\"jsonld_product\":null,");
+    }
+
+    char *products = NULL;
+    if (extract_products(html, html_len, &products) == 0 && products) {
+        printf("\"products\":");
+        print_products_json(products);
+        free(products);
+    } else {
+        printf("\"products\":null");
+    }
+
+    printf("}\n");
+
+    free(html);
+    return 0;
+}
diff --git a/src/scraper.c b/src/scraper.c
new file mode 100644
index 0000000..a8511bc
--- /dev/null
+++ b/src/scraper.c
@@ -0,0 +1,520 @@
+#include "scraper.h"
+#include <stdio.h>
+#include <string.h>
+#include <curl/curl.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/tree.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdbool.h>
+
+struct mem {
+    char *buf;
+    size_t size;
+};
+
+static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *userdata) {
+    size_t realsize = size * nmemb;
+    struct mem *m = (struct mem *)userdata;
+    char *newbuf = realloc(m->buf, m->size + realsize + 1);
+    if (!newbuf) return 0;
+    m->buf = newbuf;
+    memcpy(&(m->buf[m->size]), ptr, realsize);
+    m->size += realsize;
+    m->buf[m->size] = '\0';
+    return realsize;
+}
+
+int fetch_url(const char *url, char **out_buf, size_t *out_len) {
+    if (!url || !out_buf || !out_len) return -1;
+    CURL *curl = NULL;
+    CURLcode res;
+    struct mem chunk = {0};
+
+    curl_global_init(CURL_GLOBAL_DEFAULT);
+    curl = curl_easy_init();
+    if (!curl) {
+        curl_global_cleanup();
+        return -1;
+    }
+
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "gscrape/0.1");
+
+    res = curl_easy_perform(curl);
+    curl_easy_cleanup(curl);
+    curl_global_cleanup();
+
+    if (res != CURLE_OK) {
+        free(chunk.buf);
+        return -1;
+    }
+
+    *out_buf = chunk.buf;
+    *out_len = chunk.size;
+    return 0;
+}
+
+static xmlNode *find_title_node(xmlNode *node) {
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"title") == 0) {
+                return cur;
+            }
+            xmlNode *res = find_title_node(cur->children);
+            if (res) return res;
+        }
+    }
+    return NULL;
+}
+
+char *extract_title(const char *html, size_t len) {
+    if (!html || len == 0) return NULL;
+    htmlDocPtr doc = htmlReadMemory(html, (int)len, NULL, NULL, HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING);
+    if (!doc) return NULL;
+
+    xmlNode *root = xmlDocGetRootElement(doc);
+    xmlNode *title_node = find_title_node(root);
+    if (!title_node) {
+        xmlFreeDoc(doc);
+        return NULL;
+    }
+
+    xmlChar *content = xmlNodeGetContent(title_node);
+    if (!content) {
+        xmlFreeDoc(doc);
+        return NULL;
+    }
+
+    char *title = strdup((const char *)content);
+    xmlFree(content);
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    return title;
+}
+
+/* Helper: append formatted text to buffer (allocating). Caller owns *out. */
+static int append_fmt(char **out, size_t *out_len, const char *fmt, ...) {
+    va_list ap;
+    va_start(ap, fmt);
+    va_list ap2;
+    va_copy(ap2, ap);
+    int needed = vsnprintf(NULL, 0, fmt, ap);
+    va_end(ap);
+
+    if (needed < 0) {
+        va_end(ap2);
+        return -1;
+    }
+
+    char *newbuf = realloc(*out, *out_len + (size_t)needed + 1);
+    if (!newbuf) {
+        va_end(ap2);
+        return -1;
+    }
+    *out = newbuf;
+    vsnprintf(*out + *out_len, (size_t)needed + 1, fmt, ap2);
+    *out_len += (size_t)needed;
+    va_end(ap2);
+    return 0;
+}
+
+static void collect_meta_nodes(xmlNode *node, char **out, size_t *out_len) {
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"meta") == 0) {
+                xmlChar *name = xmlGetProp(cur, (const xmlChar *)"name");
+                xmlChar *prop = xmlGetProp(cur, (const xmlChar *)"property");
+                xmlChar *content = xmlGetProp(cur, (const xmlChar *)"content");
+                const xmlChar *key = name ? name : prop;
+                if (key && content) {
+                    append_fmt(out, out_len, "%s: %s\n", (const char *)key, (const char *)content);
+                }
+                if (name) xmlFree(name);
+                if (prop) xmlFree(prop);
+                if (content) xmlFree(content);
+            }
+            collect_meta_nodes(cur->children, out, out_len);
+        }
+    }
+}
+
+int extract_meta(const char *html, size_t len, char **out) {
+    if (!html || len == 0 || !out) return -1;
+    htmlDocPtr doc = htmlReadMemory(html, (int)len, NULL, NULL, HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING);
+    if (!doc) return -1;
+    xmlNode *root = xmlDocGetRootElement(doc);
+    *out = NULL;
+    size_t out_len = 0;
+    collect_meta_nodes(root, out, &out_len);
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    if (out_len == 0) {
+        free(*out);
+        *out = NULL;
+        return -1;
+    }
+    return 0;
+}
+
+static void collect_og_nodes(xmlNode *node, char **out, size_t *out_len) {
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"meta") == 0) {
+                xmlChar *prop = xmlGetProp(cur, (const xmlChar *)"property");
+                xmlChar *content = xmlGetProp(cur, (const xmlChar *)"content");
+                if (prop && content) {
+                    if (strncasecmp((const char *)prop, "og:", 3) == 0) {
+                        append_fmt(out, out_len, "%s: %s\n", (const char *)prop, (const char *)content);
+                    }
+                }
+                if (prop) xmlFree(prop);
+                if (content) xmlFree(content);
+            }
+            collect_og_nodes(cur->children, out, out_len);
+        }
+    }
+}
+
+int extract_og(const char *html, size_t len, char **out) {
+    if (!html || len == 0 || !out) return -1;
+    htmlDocPtr doc = htmlReadMemory(html, (int)len, NULL, NULL, HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING);
+    if (!doc) return -1;
+    xmlNode *root = xmlDocGetRootElement(doc);
+    *out = NULL;
+    size_t out_len = 0;
+    collect_og_nodes(root, out, &out_len);
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    if (out_len == 0) {
+        free(*out);
+        *out = NULL;
+        return -1;
+    }
+    return 0;
+}
+
+static char *get_node_content(xmlNode *node) {
+    xmlChar *content = xmlNodeGetContent(node);
+    if (!content) return NULL;
+    char *res = strdup((const char *)content);
+    xmlFree(content);
+    return res;
+}
+
+int extract_jsonld_product(const char *html, size_t len, char **out_json) {
+    if (!html || len == 0 || !out_json) return -1;
+    htmlDocPtr doc = htmlReadMemory(html, (int)len, NULL, NULL, HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING);
+    if (!doc) return -1;
+    xmlNode *root = xmlDocGetRootElement(doc);
+    *out_json = NULL;
+
+    for (xmlNode *cur = root; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"script") == 0) {
+                xmlChar *type = xmlGetProp(cur, (const xmlChar *)"type");
+                if (type && xmlStrcasecmp(type, (const xmlChar *)"application/ld+json") == 0) {
+                    char *content = get_node_content(cur);
+                    if (content) {
+                        /* crude check for Product */
+                        if ((strcasestr(content, "\"@type\"") && strcasestr(content, "Product")) || strcasestr(content, "\"Product\"")) {
+                            *out_json = content; /* transfer ownership */
+                            xmlFree(type);
+                            xmlFreeDoc(doc);
+                            xmlCleanupParser();
+                            return 0;
+                        }
+                        free(content);
+                    }
+                }
+                if (type) xmlFree(type);
+            }
+            /* search children */
+            if (cur->children) {
+                /* recurse using a stack-like traversal by resetting cur to children
+                 * then letting the outer loop walk siblings. Simpler: call function
+                 * recursively — but here we inline a nested loop to find scripts.
+                 */
+                xmlNode *child = cur->children;
+                while (child) {
+                    if (child->type == XML_ELEMENT_NODE && xmlStrcasecmp(child->name, (const xmlChar *)"script") == 0) {
+                        xmlChar *type = xmlGetProp(child, (const xmlChar *)"type");
+                        if (type && xmlStrcasecmp(type, (const xmlChar *)"application/ld+json") == 0) {
+                            char *content = get_node_content(child);
+                            if (content) {
+                                if ((strcasestr(content, "\"@type\"") && strcasestr(content, "Product")) || strcasestr(content, "\"Product\"")) {
+                                    *out_json = content;
+                                    if (type) xmlFree(type);
+                                    xmlFreeDoc(doc);
+                                    xmlCleanupParser();
+                                    return 0;
+                                }
+                                free(content);
+                            }
+                        }
+                        if (type) xmlFree(type);
+                    }
+                    child = child->next;
+                }
+            }
+        }
+    }
+
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    return -1;
+}
+
+static xmlNode *find_h1_node(xmlNode *node) {
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"h1") == 0) {
+                return cur;
+            }
+            xmlNode *res = find_h1_node(cur->children);
+            if (res) return res;
+        }
+    }
+    return NULL;
+}
+
+char *extract_h1(const char *html, size_t len) {
+    if (!html || len == 0) return NULL;
+    htmlDocPtr doc = htmlReadMemory(html, (int)len, NULL, NULL, HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING);
+    if (!doc) return NULL;
+    xmlNode *root = xmlDocGetRootElement(doc);
+    xmlNode *h1 = find_h1_node(root);
+    if (!h1) {
+        xmlFreeDoc(doc);
+        return NULL;
+    }
+    char *res = get_node_content(h1);
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    return res;
+}
+
+/* Heuristic product extraction */
+static bool attr_contains(const xmlChar *attr, const char *needle) {
+    if (!attr || !needle) return false;
+    return (strcasestr((const char *)attr, needle) != NULL);
+}
+
+static char *find_name_in_node(xmlNode *node) {
+    if (!node) return NULL;
+    /* look for h1-h4, a, or elements with class/id containing name/title/product */
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"h1") == 0 ||
+                xmlStrcasecmp(cur->name, (const xmlChar *)"h2") == 0 ||
+                xmlStrcasecmp(cur->name, (const xmlChar *)"h3") == 0 ||
+                xmlStrcasecmp(cur->name, (const xmlChar *)"h4") == 0) {
+                char *txt = get_node_content(cur);
+                if (txt && strlen(txt) > 1 && strlen(txt) < 200) return txt;
+                if (txt) free(txt);
+            }
+
+            xmlChar *cls = xmlGetProp(cur, (const xmlChar *)"class");
+            xmlChar *id = xmlGetProp(cur, (const xmlChar *)"id");
+            if ((cls && (attr_contains(cls, "title") || attr_contains(cls, "name") || attr_contains(cls, "product"))) ||
+                (id && (attr_contains(id, "title") || attr_contains(id, "name") || attr_contains(id, "product")))) {
+                /* Avoid returning anchor text (which may include price); prefer
+                   headings or specific child elements. If current node is an
+                   anchor, recurse into children instead of returning its text. */
+                if (xmlStrcasecmp(cur->name, (const xmlChar *)"a") != 0) {
+                    char *txt = get_node_content(cur);
+                    if (txt && strlen(txt) > 0 && strlen(txt) < 200) {
+                        if (cls) xmlFree(cls);
+                        if (id) xmlFree(id);
+                        return txt;
+                    }
+                    if (txt) free(txt);
+                }
+            }
+            if (cls) xmlFree(cls);
+            if (id) xmlFree(id);
+
+            char *res = find_name_in_node(cur->children);
+            if (res) return res;
+        }
+    }
+    return NULL;
+}
+
+static char *find_href_in_node(xmlNode *node) {
+    if (!node) return NULL;
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            if (xmlStrcasecmp(cur->name, (const xmlChar *)"a") == 0) {
+                xmlChar *href = xmlGetProp(cur, (const xmlChar *)"href");
+                if (href) {
+                    char *res = strdup((const char *)href);
+                    xmlFree(href);
+                    return res;
+                }
+            }
+            char *res = find_href_in_node(cur->children);
+            if (res) return res;
+        }
+    }
+    return NULL;
+}
+
+static char *find_price_in_node(xmlNode *node) {
+    if (!node) return NULL;
+    /* Check element's attributes for obvious price strings */
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            xmlChar *cls = xmlGetProp(cur, (const xmlChar *)"class");
+            xmlChar *id = xmlGetProp(cur, (const xmlChar *)"id");
+            if ((cls && attr_contains(cls, "price")) || (id && attr_contains(id, "price"))) {
+                char *txt = get_node_content(cur);
+                if (cls) xmlFree(cls);
+                if (id) xmlFree(id);
+                if (txt && strlen(txt) > 0 && strlen(txt) < 200) return txt;
+                if (txt) free(txt);
+            }
+            if (cls) xmlFree(cls);
+            if (id) xmlFree(id);
+
+            /* Check textual content for currency symbols */
+            char *txt = get_node_content(cur);
+            if (txt) {
+                /* Avoid returning container text (e.g., anchor that includes title
+                 * and price). Only accept textual matches when the element is not
+                 * an anchor or heading.
+                 */
+                if (xmlStrcasecmp(cur->name, (const xmlChar *)"a") != 0 &&
+                    xmlStrcasecmp(cur->name, (const xmlChar *)"h1") != 0 &&
+                    xmlStrcasecmp(cur->name, (const xmlChar *)"h2") != 0 &&
+                    (strchr(txt, '$') || strchr(txt, '£') || strchr(txt, '€') || strstr(txt, "USD") || strstr(txt, "EUR"))) {
+                    if (strlen(txt) < 200) {
+                        char *trim = strdup(txt);
+                        free(txt);
+                        return trim;
+                    }
+                }
+                free(txt);
+            }
+
+            char *res = find_price_in_node(cur->children);
+            if (res) return res;
+        }
+    }
+    return NULL;
+}
+
+/* Collect product information for a node that appears to be a product item.
+ * Looks for h2.product-name and span.price preferentially, falls back to
+ * generic name/price finders.
+ */
+static void collect_product_from_node(xmlNode *node, char **out, size_t *out_len, int *found) {
+    if (!node) return;
+    char *name = NULL;
+    char *price = NULL;
+    char *plink = NULL;
+
+    /* Prefer h2 with class 'product-name' or titles */
+    for (xmlNode *c = node->children; c; c = c->next) {
+        if (c->type != XML_ELEMENT_NODE) continue;
+        xmlChar *cls = xmlGetProp(c, (const xmlChar *)"class");
+        if (xmlStrcasecmp(c->name, (const xmlChar *)"h2") == 0 && cls) {
+            if (attr_contains(cls, "product-name") || attr_contains(cls, "woocommerce-loop-product__title") || attr_contains(cls, "product-title")) {
+                name = get_node_content(c);
+                xmlFree(cls);
+                break;
+            }
+        }
+        if (cls) xmlFree(cls);
+    }
+
+    /* Price: look for span with class 'price' or data-products='price' */
+    if (!price) {
+        for (xmlNode *c = node->children; c; c = c->next) {
+            if (c->type != XML_ELEMENT_NODE) continue;
+            xmlChar *cls = xmlGetProp(c, (const xmlChar *)"class");
+            xmlChar *dp = xmlGetProp(c, (const xmlChar *)"data-products");
+            if (cls && attr_contains(cls, "price")) {
+                price = get_node_content(c);
+                if (cls) xmlFree(cls);
+                if (dp) xmlFree(dp);
+                break;
+            }
+            if (dp && attr_contains(dp, "price")) {
+                price = get_node_content(c);
+                if (cls) xmlFree(cls);
+                if (dp) xmlFree(dp);
+                break;
+            }
+            if (cls) xmlFree(cls);
+            if (dp) xmlFree(dp);
+        }
+    }
+
+    /* Fallbacks */
+    if (!name) name = find_name_in_node(node->children);
+    if (!price) price = find_price_in_node(node->children);
+    /* find product link if available */
+    plink = find_href_in_node(node);
+    if (!plink) plink = strdup("<no-link>");
+
+    if (name || price) {
+        if (!name) name = strdup("<no-name>");
+        if (!price) price = strdup("<no-price>");
+        append_fmt(out, out_len, "%s | %s | %s\n", name, price, plink);
+        (*found)++;
+    }
+    if (name) free(name);
+    if (price) free(price);
+    free(plink);
+}
+
+static void traverse_and_collect_products(xmlNode *node, char **out, size_t *out_len, int *found) {
+    for (xmlNode *cur = node; cur; cur = cur->next) {
+        if (cur->type != XML_ELEMENT_NODE) continue;
+
+        xmlChar *data_products = xmlGetProp(cur, (const xmlChar *)"data-products");
+        xmlChar *itemtype = xmlGetProp(cur, (const xmlChar *)"itemtype");
+        xmlChar *cls = xmlGetProp(cur, (const xmlChar *)"class");
+
+        bool is_product = false;
+        if (data_products && attr_contains(data_products, "item")) is_product = true;
+        else if (itemtype && attr_contains(itemtype, "Product")) is_product = true;
+        else if (cls && xmlStrcasecmp(cur->name, (const xmlChar *)"li") == 0 && attr_contains(cls, "product")) is_product = true;
+
+        if (is_product) {
+            collect_product_from_node(cur, out, out_len, found);
+        }
+
+        if (data_products) xmlFree(data_products);
+        if (itemtype) xmlFree(itemtype);
+        if (cls) xmlFree(cls);
+
+        if (cur->children) traverse_and_collect_products(cur->children, out, out_len, found);
+    }
+}
+
+int extract_products(const char *html, size_t len, char **out) {
+    if (!html || len == 0 || !out) return -1;
+    htmlDocPtr doc = htmlReadMemory(html, (int)len, NULL, NULL, HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING);
+    if (!doc) return -1;
+    xmlNode *root = xmlDocGetRootElement(doc);
+
+    *out = NULL;
+    size_t out_len = 0;
+    int found = 0;
+
+    traverse_and_collect_products(root, out, &out_len, &found);
+
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    if (found == 0) {
+        free(*out);
+        *out = NULL;
+        return -1;
+    }
+    return 0;
+}