Upload 9 files

.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.env
+.env.*
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.DS_Store
+.gradio/
+gradio_cached_examples/
+flagged/
+state/
+*.log

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,15 +1,112 @@
 ---
-title: Briefing 32
-emoji: 🏆
-colorFrom: gray
-colorTo: pink
+title: briefing-32
+emoji: 📰
+colorFrom: red
+colorTo: gray
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: AI-news briefing the maker runs every 2 hours.
+short_description: A 32B-class AI-news briefing the maker runs every 2 hours.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# briefing-32
+
+A small-model AI-news briefing agent. Submission for the **Hugging Face
+Build Small Hackathon** ([huggingface.co/build-small-hackathon](https://huggingface.co/build-small-hackathon))
+in the **Backyard AI** track.
+
+## What it is
+
+This is a deliberate down-port of [`ai-news-agent`](https://github.com/MukundaKatta/ai-news-agent),
+a personal cron that already runs every two hours on the maker's laptop to
+deliver an AI-news digest to WhatsApp. The production cron uses Groq
+Llama-3.3-70B for relevance scoring. Build Small forces the same workflow
+under 32B parameters.
+
+The honest story for the Backyard AI track:
+
+> "I have used a personal AI-news briefing every two hours since spring 2026.
+> The original uses a 70B model on a free Groq tier. Build Small asked me to
+> live under 32B, on a laptop. So I split the single 70B scoring pass into
+> two cheaper passes on Qwen3-32B — a binary relevance filter, then a graded
+> ranker — and the digest quality holds up."
+
+## Pipeline
+
+```
+fetch (RSS · HN · arXiv · GitHub)
+        │
+        ▼
+pass 1 — binary relevance filter on Qwen3-32B
+        │
+        ▼
+pass 2 — graded 0–10 ranker on Qwen3-32B
+        │
+        ▼
+digest renderer on Qwen3-32B
+```
+
+Two small-model calls do the work one big-model call did before.
+
+## Sources (no Reddit / Bluesky)
+
+- **RSS / Atom**: Anthropic, OpenAI, DeepMind, Google AI, Meta AI, Mistral,
+  xAI, HuggingFace, Latent Space, Import AI, The Rundown AI, Stratechery,
+  Simon Willison, Karpathy, Lilian Weng, Linus Lee, and several more
+  high-signal blogs and newsletters.
+- **Hacker News**: AI-tagged stories via the Algolia public API.
+- **arXiv**: newest `cs.AI` / `cs.CL` / `cs.LG` submissions.
+- **GitHub**: repos with `topic:ai` created in the last 14 days, sorted by stars.
+
+Reddit and Bluesky public endpoints both 403-block traffic in 2026, so the
+port drops them. The production cron has the same scars in its logs.
+
+## Run locally
+
+```sh
+pip install -r requirements.txt
+HF_TOKEN=hf_xxx python app.py
+```
+
+Then open the Gradio URL it prints. Click **Run briefing**.
+
+## Run as an HF Space
+
+The repo is shaped like a standard Hugging Face Space. The `README.md`
+front-matter wires `app.py` as the entry point and pins the Gradio SDK.
+After deploy, the Space's "Settings → Variables and secrets" gets one
+secret: `HF_TOKEN` (a read-permission token is plenty).
+
+## Model
+
+Default model: **Qwen/Qwen3-32B** (Apache 2.0, 32B dense, native JSON mode),
+routed through HF Inference Providers.
+
+Alternatives that fit Build Small's ≤32B cap and were considered:
+`Qwen/Qwen3-30B-A3B`, `deepseek-ai/DeepSeek-R1-Distill-Qwen-32B`,
+`mistralai/Mistral-Small-24B-Instruct-2501`. Swap in the sidebar.
+
+## Targeted bonus quests
+
+The hackathon has six optional bonus quests. This submission targets:
+
+- **Field Notes** — a write-up about the 70B → 32B down-port and what
+  surprised me (see `docs/down-port-notes.md` after the build window).
+- **Sharing is Caring** — a captured agent trace published alongside the
+  Space (see `docs/sample-trace.md`).
+- **Off-Brand** — custom Gradio theme + layout (see `app.py`).
+
+Optional stretch: **Llama Champion** (a llama.cpp variant for the same
+pipeline) + **Off the Grid** (the llama.cpp variant doubles for that badge).
+
+## License
+
+Apache 2.0.
+
+## Credit
+
+Built by [Mukunda Katta](https://github.com/MukundaKatta) as an independent
+project for Build Small. The production cron it down-ports is
+[`MukundaKatta/ai-news-agent`](https://github.com/MukundaKatta/ai-news-agent).

app.py

@@ -0,0 +1,222 @@
+"""briefing-32 — Gradio app entry for Hugging Face Spaces.
+
+Build Small Hackathon submission (Backyard AI track):
+A small-model down-port of ~/ai-news-agent. The production version uses
+Groq Llama-3.3-70B; this version fits the same workflow under 32B params
+using Qwen3-32B via Hugging Face Inference Providers.
+
+Same pipeline as the every-2-hours cron the maker has running on a laptop:
+fetch RSS / HN / arXiv / GitHub -> two-pass relevance filter + ranker ->
+readable digest. Gradio is the delivery surface here instead of WhatsApp.
+"""
+from __future__ import annotations
+
+import os
+import time
+from typing import Any
+
+import gradio as gr
+import pandas as pd
+
+from config import (
+    DEFAULT_BASE_URL,
+    DEFAULT_MODEL,
+    MIN_NEW_ITEMS,
+    PER_SOURCE_CAP,
+)
+from digest import make_digest
+from fetch import fetch_all
+from rank import RankerConfig, rank_pipeline
+
+
+# ---------------------------------------------------------------------------
+# Core pipeline (callable from Gradio + scripts/cli.py)
+# ---------------------------------------------------------------------------
+
+
+def run_briefing(
+    window_hours: int,
+    enabled_sources: list[str],
+    model: str,
+    hf_token: str,
+) -> dict[str, Any]:
+    """Fetch -> filter -> rank -> digest. Returns everything for the UI."""
+    since_ts = time.time() - window_hours * 3600
+    enabled = set(enabled_sources) if enabled_sources else {"rss", "hn", "arxiv", "github"}
+
+    t0 = time.perf_counter()
+    raw = fetch_all(since_ts, enabled=enabled)
+    fetch_latency = time.perf_counter() - t0
+
+    cfg = RankerConfig(
+        base_url=DEFAULT_BASE_URL,
+        model=model or DEFAULT_MODEL,
+        api_key=hf_token or "",
+    )
+    result = rank_pipeline(raw, cfg=cfg)
+
+    digest = ""
+    if result.after_rank >= MIN_NEW_ITEMS:
+        digest = make_digest(result.items, cfg=cfg)
+    elif result.after_rank > 0:
+        digest = make_digest(result.items, cfg=cfg)
+
+    return {
+        "digest":         digest or "_(no high-signal items in window)_",
+        "items":          result.items,
+        "raw_count":      result.raw_count,
+        "after_filter":   result.after_filter,
+        "after_rank":     result.after_rank,
+        "fetch_latency":  fetch_latency,
+        "filter_latency": result.filter_latency,
+        "rank_latency":   result.rank_latency,
+        "model":          cfg.model,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Gradio glue
+# ---------------------------------------------------------------------------
+
+
+def _items_to_df(items: list[dict]) -> pd.DataFrame:
+    if not items:
+        return pd.DataFrame(columns=["score", "source", "title", "reason", "url"])
+    rows = [
+        {
+            "score":  it.get("score", 0),
+            "source": it.get("source", ""),
+            "title":  it.get("title", ""),
+            "reason": it.get("reason", ""),
+            "url":    it.get("url", ""),
+        }
+        for it in items
+    ]
+    return pd.DataFrame(rows)
+
+
+def _stats_md(result: dict[str, Any]) -> str:
+    return (
+        f"**Model:** `{result['model']}`  \n"
+        f"**Raw items fetched:** {result['raw_count']}  \n"
+        f"**Survived filter:** {result['after_filter']}  \n"
+        f"**Survived rank (score ≥ 6):** {result['after_rank']}  \n"
+        f"**Fetch latency:** {result['fetch_latency']:.1f}s  \n"
+        f"**Filter latency:** {result['filter_latency']:.1f}s  \n"
+        f"**Rank latency:** {result['rank_latency']:.1f}s  \n"
+        f"**Total LLM time:** {result['filter_latency'] + result['rank_latency']:.1f}s"
+    )
+
+
+def _gradio_handler(window_hours, sources, model, hf_token):
+    try:
+        result = run_briefing(
+            window_hours=int(window_hours),
+            enabled_sources=list(sources or []),
+            model=(model or DEFAULT_MODEL).strip(),
+            hf_token=(hf_token or "").strip(),
+        )
+    except Exception as e:
+        return (
+            f"**Error:** `{e}`\n\nMake sure `HF_TOKEN` is set in Space secrets "
+            f"or pasted into the sidebar.",
+            pd.DataFrame(),
+            "_no run yet_",
+        )
+    return result["digest"], _items_to_df(result["items"]), _stats_md(result)
+
+
+# Custom theme — "Off-Brand" bonus badge target.
+THEME = gr.themes.Soft(
+    primary_hue="orange",
+    secondary_hue="slate",
+    neutral_hue="zinc",
+).set(
+    body_background_fill="#0b1220",
+    body_text_color="#e2e8f0",
+    block_background_fill="#111827",
+    block_border_width="1px",
+    block_border_color="#1f2937",
+    button_primary_background_fill="#f97316",
+    button_primary_text_color="#0b1220",
+)
+
+
+with gr.Blocks(theme=THEME, title="briefing-32 · Build Small entry") as demo:
+    gr.Markdown(
+        """
+        # briefing-32
+        **A 32B-class AI-news briefing the maker runs every 2 hours.**
+
+        Build Small Hackathon entry (Backyard AI track). Down-ported from the
+        production `ai-news-agent` cron (Groq Llama-3.3-70B → WhatsApp) onto
+        Qwen3-32B served by Hugging Face Inference Providers.
+
+        Pipeline: RSS + HN + arXiv + GitHub  →  cheap relevance filter  →
+        graded 0–10 ranker  →  readable digest. Two open-weight model calls,
+        no 70B cloud round-trip required.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Controls")
+            window_hours = gr.Slider(
+                minimum=1, maximum=72, value=2, step=1,
+                label="Window (hours back)",
+                info="Production runs every 2hr — match that for the authentic story.",
+            )
+            sources = gr.CheckboxGroup(
+                choices=["rss", "hn", "arxiv", "github"],
+                value=["rss", "hn", "arxiv", "github"],
+                label="Sources",
+            )
+            model = gr.Textbox(
+                value=DEFAULT_MODEL,
+                label="Model (≤32B params)",
+                info="Default Qwen3-32B. Swap to Qwen3-30B-A3B for faster MoE inference.",
+            )
+            hf_token = gr.Textbox(
+                label="HF_TOKEN (optional — reads env if blank)",
+                placeholder="hf_…",
+                type="password",
+            )
+            run_btn = gr.Button("Run briefing", variant="primary")
+
+            gr.Markdown("### Run stats")
+            stats = gr.Markdown("_no run yet_")
+
+        with gr.Column(scale=2):
+            gr.Markdown("### Digest")
+            digest = gr.Markdown(
+                value="_Click **Run briefing** to fetch the last N hours of AI news, "
+                      "rank it on a ≤32B model, and render a readable briefing._"
+            )
+            gr.Markdown("### Ranked items")
+            items_df = gr.Dataframe(
+                headers=["score", "source", "title", "reason", "url"],
+                value=pd.DataFrame(columns=["score", "source", "title", "reason", "url"]),
+                wrap=True,
+                interactive=False,
+            )
+
+    run_btn.click(
+        _gradio_handler,
+        inputs=[window_hours, sources, model, hf_token],
+        outputs=[digest, items_df, stats],
+    )
+
+    gr.Markdown(
+        """
+        ---
+        *Build Small Hackathon · Backyard AI track. Apache 2.0.*
+        Code: [github.com/MukundaKatta/briefing-32](https://github.com/MukundaKatta/briefing-32)
+        """
+    )
+
+
+if __name__ == "__main__":
+    demo.queue(max_size=8).launch(
+        server_name=os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0"),
+        server_port=int(os.environ.get("PORT", "7860")),
+    )

config.py

@@ -0,0 +1,62 @@
+"""Config — model defaults, source list, tunables.
+
+Build Small Hackathon constraints: model must be ≤32B params and runnable on
+a laptop. Default is Qwen3-32B routed through HF Inference Providers so the
+HF Space talks to a real open-weight model with predictable cost.
+"""
+from __future__ import annotations
+
+import os
+
+# Default model — Apache 2.0, 32B dense, native JSON mode.
+DEFAULT_MODEL = os.getenv("BRIEFING_MODEL", "Qwen/Qwen3-32B")
+
+# HF Inference Providers OpenAI-compatible router.
+DEFAULT_BASE_URL = os.getenv("BRIEFING_BASE_URL", "https://router.huggingface.co/v1")
+
+# Smart-batch threshold for the digest section. Below this, the UI says
+# "nothing high-signal in the window" rather than rendering noise.
+MIN_NEW_ITEMS = int(os.getenv("MIN_NEW_ITEMS", "3"))
+
+# Per-source cap to bound prompt size.
+PER_SOURCE_CAP = int(os.getenv("PER_SOURCE_CAP", "20"))
+
+# Minimum relevance score (0-10) to make it into the digest.
+MIN_RELEVANCE = int(os.getenv("MIN_RELEVANCE", "6"))
+
+# Top-N items to put into the digest prompt after ranking.
+DIGEST_TOP_N = int(os.getenv("DIGEST_TOP_N", "12"))
+
+# ArXiv categories pulled live.
+ARXIV_CATEGORIES = ["cs.AI", "cs.CL", "cs.LG"]
+
+# GitHub trending topic filter.
+GITHUB_TRENDING_TOPIC = "ai"
+
+# RSS feeds — lab blogs + high-signal newsletters + YouTube channels.
+RSS_FEEDS: list[tuple[str, str]] = [
+    # AI labs
+    ("Anthropic",                "https://www.anthropic.com/news/rss.xml"),
+    ("OpenAI",                   "https://openai.com/news/rss.xml"),
+    ("Google DeepMind",          "https://deepmind.google/blog/rss.xml"),
+    ("Google AI",                "https://blog.google/technology/ai/rss/"),
+    ("Meta AI",                  "https://ai.meta.com/blog/rss/"),
+    ("Mistral",                  "https://mistral.ai/news/feed.xml"),
+    ("xAI",                      "https://x.ai/blog/rss.xml"),
+    ("HuggingFace",              "https://huggingface.co/blog/feed.xml"),
+    # Newsletters / blogs
+    ("Latent Space",             "https://www.latent.space/feed"),
+    ("Import AI",                "https://importai.substack.com/feed"),
+    ("The Rundown AI",           "https://www.therundown.ai/feed"),
+    ("Stratechery",              "https://stratechery.com/feed/"),
+    ("Simon Willison",           "https://simonwillison.net/atom/everything/"),
+    ("Andrej Karpathy",          "https://karpathy.github.io/feed.xml"),
+    ("One Useful Thing",         "https://www.oneusefulthing.org/feed"),
+    ("AI Snake Oil",             "https://www.aisnakeoil.com/feed"),
+    ("Last Week in AI",          "https://lastweekin.ai/feed"),
+    ("AI Tidbits",               "https://aitidbits.substack.com/feed"),
+    ("Linus Lee",                "https://thesephist.com/posts.xml"),
+    ("Lilian Weng",              "https://lilianweng.github.io/index.xml"),
+    # YouTube (Atom feeds, no key required)
+    ("YT: Yannic Kilcher",       "https://www.youtube.com/feeds/videos.xml?channel_id=UCZHmQk67mSJgfCCTn7xBfew"),
+]

digest.py

@@ -0,0 +1,53 @@
+"""Digest renderer — turns top-N ranked items into a readable briefing."""
+from __future__ import annotations
+
+import json
+
+from config import DIGEST_TOP_N
+from rank import RankerConfig, _chat
+
+
+_DIGEST_SYSTEM = "You write tight, useful AI-news briefings. No fluff."
+
+
+_DIGEST_PROMPT = """Write a 2-hour AI-news briefing from the items below.
+
+RULES:
+- Group by theme if obvious (Models / Research / Tools / Industry); otherwise a flat list.
+- Each item: 1-2 lines in plain English. End the item with the URL on its own line.
+- Lead with WHAT CHANGED and WHY IT MATTERS — not the source name.
+- No markdown headers, no bold asterisks. Optional bullet (•).
+- Skip items that are obvious duplicates or hype with no concrete new info.
+- Close with a one-line meta note ("3 from labs, 2 from research, 1 from tools" style).
+- Target ~1500 chars total. Stay short. Skip filler.
+
+Items (ranked by importance, highest first):
+{items_json}
+"""
+
+
+def make_digest(ranked: list[dict], cfg: RankerConfig | None = None) -> str:
+    """Render the top-N ranked items as a readable briefing."""
+    if not ranked:
+        return "_(no high-signal items in window)_"
+    cfg = cfg or RankerConfig()
+    top = ranked[:DIGEST_TOP_N]
+    indexed = [
+        {
+            "source":  it.get("source", ""),
+            "title":   (it.get("title") or "")[:200],
+            "url":     it.get("url", ""),
+            "summary": (it.get("summary") or "")[:300],
+            "score":   it.get("score", 5),
+            "reason":  it.get("reason", ""),
+        }
+        for it in top
+    ]
+    return _chat(
+        cfg,
+        _DIGEST_SYSTEM,
+        _DIGEST_PROMPT.format(items_json=json.dumps(indexed, ensure_ascii=False, indent=2)),
+        json_mode=False,
+        temperature=0.3,
+        max_tokens=2000,
+    ).strip()

fetch.py

@@ -0,0 +1,241 @@
+"""Fetchers — RSS, Hacker News, ArXiv, GitHub.
+
+All return a uniform `Item` shape so the ranker doesn't care about origin:
+    {source, title, url, summary, published_ts}
+
+Ported from `~/ai-news-agent/sources/` with two changes:
+  1. No external config.py import — everything lives in briefing.config
+  2. Reddit + Bluesky removed (both 403-block public traffic in 2026)
+"""
+from __future__ import annotations
+
+import os
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Iterable
+from xml.etree import ElementTree as ET
+
+import feedparser
+import httpx
+
+from config import (
+    ARXIV_CATEGORIES,
+    GITHUB_TRENDING_TOPIC,
+    PER_SOURCE_CAP,
+    RSS_FEEDS,
+)
+
+
+# ---------------------------------------------------------------------------
+# RSS / Atom
+# ---------------------------------------------------------------------------
+
+
+def fetch_rss(since_ts: float, feeds: Iterable[tuple[str, str]] = RSS_FEEDS) -> list[dict]:
+    items: list[dict] = []
+    for label, url in feeds:
+        try:
+            feed = feedparser.parse(url)
+        except Exception as e:
+            print(f"[rss] {label} failed: {e}")
+            continue
+        for entry in feed.entries[:PER_SOURCE_CAP]:
+            published = _entry_time(entry)
+            if published and published < since_ts:
+                continue
+            items.append(
+                {
+                    "source":       f"rss:{label}",
+                    "title":        (entry.get("title") or "").strip(),
+                    "url":          entry.get("link") or "",
+                    "summary":      (entry.get("summary") or "")[:500],
+                    "published_ts": published or time.time(),
+                }
+            )
+    return items
+
+
+def _entry_time(entry) -> float | None:
+    for key in ("published_parsed", "updated_parsed"):
+        t = entry.get(key)
+        if t:
+            return time.mktime(t)
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Hacker News via Algolia (no key)
+# ---------------------------------------------------------------------------
+
+
+_ALGOLIA = "https://hn.algolia.com/api/v1/search_by_date"
+_HN_TERMS = ["AI", "LLM", "Anthropic", "OpenAI", "Claude", "Gemini", "Llama", "agent"]
+
+
+def fetch_hn(since_ts: float) -> list[dict]:
+    items: list[dict] = []
+    seen: set[int] = set()
+    cutoff = int(since_ts)
+    with httpx.Client(timeout=15) as client:
+        for term in _HN_TERMS:
+            try:
+                r = client.get(
+                    _ALGOLIA,
+                    params={
+                        "query": term,
+                        "tags": "story",
+                        "numericFilters": f"created_at_i>{cutoff},points>10",
+                        "hitsPerPage": PER_SOURCE_CAP,
+                    },
+                )
+                r.raise_for_status()
+                for hit in r.json().get("hits", []):
+                    obj_id = hit.get("objectID")
+                    if obj_id in seen:
+                        continue
+                    seen.add(obj_id)
+                    items.append(
+                        {
+                            "source":       "hn",
+                            "title":        hit.get("title") or hit.get("story_title") or "",
+                            "url":          hit.get("url")
+                                            or f"https://news.ycombinator.com/item?id={obj_id}",
+                            "summary":      f"{hit.get('points', 0)} pts, "
+                                            f"{hit.get('num_comments', 0)} comments",
+                            "published_ts": hit.get("created_at_i") or time.time(),
+                        }
+                    )
+            except Exception as e:
+                print(f"[hn] term={term} failed: {e}")
+    return items
+
+
+# ---------------------------------------------------------------------------
+# ArXiv
+# ---------------------------------------------------------------------------
+
+
+_NS = {"a": "http://www.w3.org/2005/Atom"}
+
+
+def fetch_arxiv(since_ts: float) -> list[dict]:
+    items: list[dict] = []
+    cat_query = " OR ".join(f"cat:{c}" for c in ARXIV_CATEGORIES)
+    with httpx.Client(timeout=20) as client:
+        try:
+            r = client.get(
+                "https://export.arxiv.org/api/query",
+                params={
+                    "search_query": cat_query,
+                    "sortBy":       "submittedDate",
+                    "sortOrder":    "descending",
+                    "max_results":  PER_SOURCE_CAP,
+                },
+            )
+            r.raise_for_status()
+            root = ET.fromstring(r.text)
+            for entry in root.findall("a:entry", _NS):
+                title = (entry.findtext("a:title", default="", namespaces=_NS) or "").strip()
+                summary = (entry.findtext("a:summary", default="", namespaces=_NS) or "").strip()
+                published = entry.findtext("a:published", default="", namespaces=_NS) or ""
+                link_el = entry.find("a:link[@rel='alternate']", _NS)
+                url = link_el.get("href") if link_el is not None else ""
+                ts = _iso_ts(published)
+                if ts < since_ts:
+                    continue
+                items.append(
+                    {
+                        "source":       "arxiv",
+                        "title":        title.replace("\n", " "),
+                        "url":          url,
+                        "summary":      summary[:500].replace("\n", " "),
+                        "published_ts": ts or time.time(),
+                    }
+                )
+        except Exception as e:
+            print(f"[arxiv] failed: {e}")
+    return items
+
+
+def _iso_ts(s: str) -> float:
+    try:
+        return time.mktime(time.strptime(s[:19], "%Y-%m-%dT%H:%M:%S"))
+    except Exception:
+        return 0.0
+
+
+# ---------------------------------------------------------------------------
+# GitHub trending (topic:ai)
+# ---------------------------------------------------------------------------
+
+
+_GH = "https://api.github.com"
+
+
+def fetch_github(since_ts: float) -> list[dict]:
+    cutoff = (datetime.now(timezone.utc) - timedelta(days=14)).strftime("%Y-%m-%d")
+    headers = {"Accept": "application/vnd.github+json"}
+    if os.environ.get("GITHUB_TOKEN"):
+        headers["Authorization"] = f"Bearer {os.environ['GITHUB_TOKEN']}"
+    items: list[dict] = []
+    with httpx.Client(timeout=15, headers=headers) as client:
+        try:
+            r = client.get(
+                f"{_GH}/search/repositories",
+                params={
+                    "q":        f"topic:{GITHUB_TRENDING_TOPIC} created:>{cutoff}",
+                    "sort":     "stars",
+                    "order":    "desc",
+                    "per_page": PER_SOURCE_CAP,
+                },
+            )
+            r.raise_for_status()
+            for repo in r.json().get("items", []):
+                ts = _iso_ts(repo.get("pushed_at", ""))
+                if ts < since_ts:
+                    continue
+                items.append(
+                    {
+                        "source":       "github",
+                        "title":        f"{repo['full_name']} — "
+                                        f"{repo.get('description') or ''}".strip(),
+                        "url":          repo["html_url"],
+                        "summary":      f"{repo.get('stargazers_count', 0)} stars, "
+                                        f"language={repo.get('language', '?')}",
+                        "published_ts": ts or time.time(),
+                    }
+                )
+        except Exception as e:
+            print(f"[github] failed: {e}")
+    return items
+
+
+# ---------------------------------------------------------------------------
+# Aggregate
+# ---------------------------------------------------------------------------
+
+
+def fetch_all(since_ts: float, *, enabled: set[str] | None = None) -> list[dict]:
+    """Run every enabled fetcher. `enabled` is a set like {'rss', 'hn'}.
+
+    `None` means run all. Returns a flat list of Items.
+    """
+    fetchers: dict[str, callable] = {
+        "rss":    fetch_rss,
+        "hn":     fetch_hn,
+        "arxiv":  fetch_arxiv,
+        "github": fetch_github,
+    }
+    if enabled is None:
+        enabled = set(fetchers.keys())
+    out: list[dict] = []
+    for name, fn in fetchers.items():
+        if name not in enabled:
+            continue
+        try:
+            chunk = fn(since_ts)
+            print(f"[fetch] {name}: {len(chunk)} items")
+            out.extend(chunk)
+        except Exception as e:
+            print(f"[fetch] {name} crashed: {e}")
+    return out

rank.py

@@ -0,0 +1,201 @@
+"""Two-pass ranker on a ≤32B open-weight model via HF Inference Providers.
+
+Pass 1: cheap relevance filter — for each item, "is this AI news worth a
+        senior engineer's two minutes?" Yes/no.
+Pass 2: structured 0-10 ranking on the survivors. Surfaces the top items.
+
+The down-port story for Build Small: the production ai-news-agent runs a
+single 70B-Groq scoring pass over the full batch. That works but it spends
+70B-class budget on items that are obviously noise (HN posts about
+non-AI scams that hit the AI keyword set). At 32B we split the work — a
+cheap binary filter first to drop obvious junk, then a graded score on the
+real candidates. Same end signal, half the prompt tokens at the expensive
+step.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass
+
+import httpx
+
+from config import DEFAULT_BASE_URL, DEFAULT_MODEL, MIN_RELEVANCE
+
+
+# ---------------------------------------------------------------------------
+# Provider client
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class RankerConfig:
+    base_url: str = DEFAULT_BASE_URL
+    model:    str = DEFAULT_MODEL
+    api_key:  str = ""           # populated from HF_TOKEN at call time if blank
+    timeout:  float = 90.0
+
+
+def _client(cfg: RankerConfig) -> httpx.Client:
+    api_key = cfg.api_key or os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_TOKEN", "")
+    if not api_key:
+        raise RuntimeError(
+            "HF_TOKEN missing — set it in the environment or pass api_key= explicitly."
+        )
+    return httpx.Client(
+        base_url=cfg.base_url,
+        timeout=cfg.timeout,
+        headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+    )
+
+
+def _chat(cfg: RankerConfig, system: str, user: str, *, json_mode: bool = True,
+          temperature: float = 0.2, max_tokens: int = 4000) -> str:
+    payload = {
+        "model":       cfg.model,
+        "messages":    [
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        "temperature": temperature,
+        "max_tokens":  max_tokens,
+    }
+    if json_mode:
+        payload["response_format"] = {"type": "json_object"}
+    with _client(cfg) as cli:
+        r = cli.post("/chat/completions", json=payload)
+        r.raise_for_status()
+        return r.json()["choices"][0]["message"]["content"]
+
+
+# ---------------------------------------------------------------------------
+# Pass 1 — binary relevance filter
+# ---------------------------------------------------------------------------
+
+
+_FILTER_SYSTEM = "You are a precise JSON-only classifier. No prose."
+
+
+_FILTER_PROMPT = """You are pre-filtering items for a 2-hour AI-news briefing for a senior AI engineer.
+
+Mark each item KEEP if it is AI/ML news that a senior engineer would care about (model releases, capability shifts, key research, important industry moves, notable benchmarks, infrastructure changes). Mark DROP if it is noise, off-topic, hype-with-no-substance, repeat news from earlier today, or non-AI items.
+
+Return JSON only:
+  {{"verdicts": [{{"i": 0, "v": "KEEP"}}, {{"i": 1, "v": "DROP"}}, ...]}}
+
+Items:
+{items_json}
+"""
+
+
+def filter_relevant(items: list[dict], cfg: RankerConfig | None = None) -> list[dict]:
+    """Pass 1 — drop obvious noise. Returns items that survived."""
+    if not items:
+        return []
+    cfg = cfg or RankerConfig()
+    indexed = [
+        {"i": i, "source": it.get("source", ""), "title": (it.get("title") or "")[:200]}
+        for i, it in enumerate(items)
+    ]
+    raw = _chat(
+        cfg,
+        _FILTER_SYSTEM,
+        _FILTER_PROMPT.format(items_json=json.dumps(indexed, ensure_ascii=False)),
+    )
+    try:
+        data = json.loads(raw)
+        keep = {entry["i"] for entry in data.get("verdicts", []) if entry.get("v") == "KEEP"}
+    except Exception as e:
+        print(f"[filter] parse failed, keeping all: {e}")
+        keep = set(range(len(items)))
+    return [items[i] for i in range(len(items)) if i in keep]
+
+
+# ---------------------------------------------------------------------------
+# Pass 2 — graded ranker
+# ---------------------------------------------------------------------------
+
+
+_RANKER_SYSTEM = "You are a precise JSON-only scorer. No prose."
+
+
+_RANKER_PROMPT = """You are an AI-news editor scoring items for a 2-hour briefing for a senior AI engineer.
+
+Score each item 0-10 on importance and novelty. High scores (8-10) = major model releases, significant research breakthroughs, capability shifts, key industry moves, notable benchmarks. Medium (5-7) = relevant but smaller updates, useful tools, interesting research. Low (0-4) = noise, hype with no substance, repackaged news, off-topic.
+
+Return JSON only:
+  {{"scores": [{{"i": 0, "score": 8, "reason": "short why"}}, ...]}}
+
+Items:
+{items_json}
+"""
+
+
+def rank_items(items: list[dict], cfg: RankerConfig | None = None) -> list[dict]:
+    """Pass 2 — graded score 0-10. Items below MIN_RELEVANCE are dropped.
+
+    Returns sorted descending by score, each item gets a `score` and
+    `reason` field added.
+    """
+    if not items:
+        return []
+    cfg = cfg or RankerConfig()
+    indexed = [
+        {"i": i, "source": it.get("source", ""), "title": (it.get("title") or "")[:200]}
+        for i, it in enumerate(items)
+    ]
+    raw = _chat(
+        cfg,
+        _RANKER_SYSTEM,
+        _RANKER_PROMPT.format(items_json=json.dumps(indexed, ensure_ascii=False)),
+    )
+    try:
+        data = json.loads(raw)
+        score_map = {entry["i"]: (int(entry["score"]), entry.get("reason", ""))
+                     for entry in data.get("scores", [])}
+    except Exception as e:
+        print(f"[rank] parse failed, defaulting all to 5: {e}")
+        score_map = {i: (5, "parse error") for i in range(len(items))}
+
+    out: list[dict] = []
+    for i, item in enumerate(items):
+        score, reason = score_map.get(i, (5, ""))
+        if score < MIN_RELEVANCE:
+            continue
+        out.append({**item, "score": score, "reason": reason})
+    out.sort(key=lambda x: x["score"], reverse=True)
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Combined pipeline
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class RankResult:
+    raw_count:      int
+    after_filter:   int
+    after_rank:     int
+    items:          list[dict]
+    filter_latency: float
+    rank_latency:   float
+
+
+def rank_pipeline(items: list[dict], cfg: RankerConfig | None = None) -> RankResult:
+    """Filter then rank. Returns the surviving items plus per-stage latency."""
+    cfg = cfg or RankerConfig()
+    t0 = time.perf_counter()
+    filtered = filter_relevant(items, cfg)
+    t1 = time.perf_counter()
+    ranked = rank_items(filtered, cfg)
+    t2 = time.perf_counter()
+    return RankResult(
+        raw_count=      len(items),
+        after_filter=   len(filtered),
+        after_rank=     len(ranked),
+        items=          ranked,
+        filter_latency= t1 - t0,
+        rank_latency=   t2 - t1,
+    )

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5.0.0
+httpx>=0.27
+feedparser>=6.0.11
+pandas>=2.2