AI agent skill that researches any topic across Reddit, X, YouTube, HN, Polymarket, and the web - then synthesizes a grounded summary
Python ai-promptsai-skillblueskyclaudeclaude-codeclawhubdeep-researchhackernewsinstagramopenclawpolymarketrecencyredditresearchsocial-mediatiktoktrendstwitterweb-searchyoutube
from __future__ import annotations
import hashlib
import re
import sys
import pytest
import last30days as cli
from lib import env, html_render, registers, render, schema
SOURCES = [
"reddit",
"github",
"youtube",
"tiktok",
"instagram",
"hackernews",
"polymarket",
"grounding",
"x",
"arxiv",
"jobs",
"bluesky",
]
def fixture_report() -> schema.Report:
candidates: list[schema.Candidate] = []
clusters: list[schema.Cluster] = []
items_by_source: dict[str, list[schema.SourceItem]] = {}
for index, source in enumerate(SOURCES, start=1):
item = schema.SourceItem(
item_id=f"item-{index}",
source=source,
title=f"{source} signal with a detailed audience-ready headline {index}",
body=f"Evidence body for {source}.",
url=f"https://example.com/{source}/{index}",
author=f"voice{index}",
container="community",
published_at="2026-07-09",
date_confidence="high",
engagement={"score": 1000 - index, "likes": 2000 - index},
snippet=f"Technical and community evidence from {source}.",
metadata={
"top_comments": [
{
"excerpt": f"Memorable community reaction number {index}.",
"score": 1000 - index,
"author": f"commenter{index}",
"url": f"https://example.com/{source}/{index}#comment",
}
]
},
)
candidate = schema.Candidate(
candidate_id=f"candidate-{index}",
item_id=item.item_id,
source=source,
title=item.title,
url=item.url,
snippet=item.snippet,
subquery_labels=["primary"],
native_ranks={f"primary:{source}": index},
local_relevance=0.95,
freshness=95,
engagement=90,
source_quality=1.0,
rrf_score=0.02,
sources=[source],
source_items=[item],
rerank_score=95,
final_score=101 - index,
fun_score=90,
fun_explanation="high-signal phrasing",
)
cluster = schema.Cluster(
cluster_id=f"cluster-{index}",
title=f"{source} storyline {index}",
candidate_ids=[candidate.candidate_id],
representative_ids=[candidate.candidate_id],
sources=[source],
score=101 - index,
)
candidates.append(candidate)
clusters.append(cluster)
items_by_source[source] = [item]
return schema.Report(
topic="audience register research",
range_from="2026-06-10",
range_to="2026-07-10",
generated_at="2026-07-10T12:00:00Z",
provider_runtime=schema.ProviderRuntime(
reasoning_provider="local",
planner_model="fixture",
rerank_model="fixture",
),
query_plan=schema.QueryPlan(
intent="general",
freshness_mode="strict_recent",
cluster_mode="story",
raw_topic="audience register research",
subqueries=[
schema.SubQuery(
label="primary",
search_query="audience register research",
ranking_query="What matters?",
sources=SOURCES,
)
],
source_weights={source: 1.0 for source in SOURCES},
),
clusters=clusters,
ranked_candidates=candidates,
items_by_source=items_by_source,
errors_by_source={},
artifacts={"pre_research_flags_present": True},
)
def _headings(output: str) -> list[str]:
return re.findall(r"^## (.+)$", output, flags=re.MULTILINE)
def _cluster_count(output: str) -> int:
evidence = output.split("## Ranked Evidence Clusters", 1)[1]
evidence = evidence.split("\n## ", 1)[0]
return len(re.findall(r"^### \d+\.", evidence, flags=re.MULTILINE))
def _bullet_count(output: str, heading: str) -> int:
section = output.split(f"## {heading}", 1)[1]
section = section.split("\n## ", 1)[0]
return len(re.findall(r'^- "', section, flags=re.MULTILINE))
@pytest.mark.parametrize(
("name", "expected_order", "cluster_budget", "comment_budget"),
[
(
"exec",
["Stats", "Ranked Evidence Clusters", "Source Coverage", "Best Takes", "Top Community Comments"],
5,
3,
),
(
"dev",
["Ranked Evidence Clusters", "Source Coverage", "Stats", "Top Community Comments", "Best Takes"],
10,
4,
),
(
"creator",
["Best Takes", "Top Community Comments", "Stats", "Ranked Evidence Clusters", "Source Coverage"],
6,
# The register's own top_comments budget. It used to read 6 only
# because the comments pool was limited to the 6 visible clusters;
# the pool now spans every floor-clearing cluster.
8,
),
],
)
def test_registers_control_section_order_and_budgets(
name: str,
expected_order: list[str],
cluster_budget: int,
comment_budget: int,
):
output = render.render_compact(fixture_report(), register=name)
headings = _headings(output)
assert [heading for heading in headings if heading in expected_order] == expected_order
assert _cluster_count(output) == cluster_budget
assert _bullet_count(output, "Top Community Comments") == comment_budget
def test_emphasis_weights_promote_audience_specific_sources():
report = fixture_report()
dev = render.render_compact(report, register="dev")
creator = render.render_compact(report, register="creator")
assert "### 1. github storyline" in dev
assert "### 1. tiktok storyline" in creator
def test_creator_register_leads_markdown_and_html_with_best_takes():
report = fixture_report()
markdown = render.render_compact(report, register="creator")
html = html_render.render_html(report, register="creator")
assert markdown.index("## Best Takes") < markdown.index("## Ranked Evidence Clusters")
assert html.index("<h2>Best Takes</h2>") < html.index("<h2>Ranked Evidence Clusters</h2>")
def test_default_register_is_byte_identical_when_omitted(monkeypatch):
monkeypatch.setattr(render, "_render_badge", lambda: ["fixed badge", ""])
monkeypatch.setattr(render, "_skill_version", lambda: "fixture")
report = fixture_report()
implicit = render.render_compact(report)
explicit = render.render_compact(report, register="default")
assert implicit == explicit
assert hashlib.sha256(implicit.encode()).hexdigest() == (
# Hash includes #886's linked evidence URLs, #890's Hacker News
# comment-rendering changes, the quiet footer (no outcome text, no
# ## Source Errors in compact), and the comments pool reading every
# floor-clearing cluster, and the canonical boundary's inline-citation
# wording (no tool-contract override claim), and HN cluster-evidence
# comment lines carrying the comment's own link, and #706's fenced
# text footer, and #1082's removal of LAW N framing from model-visible
# contract text.
"7f59fe51a42de2983cc5ef863c03090f7c73d2a2e5adcea236883f14fe550ef5"
)
def test_eli5_is_renderer_equivalent_to_default():
report = fixture_report()
assert render.render_compact(report, register="eli5") == render.render_compact(
report, register="default"
)
def test_cli_and_env_register_resolution():
args = cli.build_parser().parse_args(["topic", "--register", "exec"])
assert args.register == "exec"
assert cli._audience_register_for_run(args, {}, None).name == "exec"
args = cli.build_parser().parse_args(["topic"])
assert cli._audience_register_for_run(
args, {"LAST30DAYS_REGISTER": "creator"}, None
).name == "creator"
assert cli._audience_register_for_run(
args, {"ELI5_MODE": "true"}, None
).name == "eli5"
assert cli._audience_register_for_run(
args, {"LAST30DAYS_REGISTER": "default", "ELI5_MODE": "true"}, None
).name == "default"
def test_last30days_register_round_trips_from_process_env(monkeypatch, tmp_path):
monkeypatch.setenv("LAST30DAYS_CONFIG_DIR", str(tmp_path))
monkeypatch.setenv("LAST30DAYS_REGISTER", "dev")
monkeypatch.setattr(env, "CONFIG_DIR", tmp_path)
monkeypatch.setattr(env, "CONFIG_FILE", tmp_path / "does-not-exist.env")
monkeypatch.setattr(env, "_load_keychain", lambda *args, **kwargs: {})
monkeypatch.setattr(env, "_load_pass", lambda *args, **kwargs: {})
assert env.get_config()["LAST30DAYS_REGISTER"] == "dev"
def test_registers_do_not_shape_drill_output():
args = cli.build_parser().parse_args(["--drill", "cluster 1"])
assert cli._audience_register_for_run(
args, {"LAST30DAYS_REGISTER": "creator"}, None
).name == "default"
def test_registers_do_not_shape_comparison_output():
args = cli.build_parser().parse_args(
["alpha", "vs", "beta", "--register=creator"]
)
assert cli._audience_register_for_run(args, {}, None).name == "default"
@pytest.mark.parametrize(
"topic",
[
"React/Vue",
"alpha compared to beta",
"difference between alpha and beta",
],
)
def test_registers_use_canonical_comparison_detection(topic):
args = cli.build_parser().parse_args([topic])
assert cli._audience_register_for_run(
args, {"LAST30DAYS_REGISTER": "board"}, None
).name == "default"
@pytest.mark.parametrize("topic", ["CI/CD", "alpha/beta", "https://example.com"])
def test_slash_topics_keep_single_topic_register_selection(topic):
args = cli.build_parser().parse_args([topic])
assert cli._audience_register_for_run(
args, {"LAST30DAYS_REGISTER": "creator"}, None
).name == "creator"
with pytest.raises(ValueError, match="unknown audience register 'board'"):
cli._audience_register_for_run(args, {"LAST30DAYS_REGISTER": "board"}, None)
def test_registered_html_excludes_source_failure_diagnostics():
report = fixture_report()
report.source_status["x"] = schema.SourceOutcome(
source="x",
state=schema.RATE_LIMITED,
detail="HTTP 429 after retry budget",
fix_hint="doctor",
)
report.errors_by_source["x"] = "private source error diagnostic"
html = html_render.render_html(report, register="creator")
assert "Partial Coverage" not in html
assert "Source Errors" not in html
assert "private source error diagnostic" not in html
def test_unknown_register_errors_cleanly():
with pytest.raises(ValueError, match="unknown audience register"):
registers.get_register("board")
args = cli.build_parser().parse_args(["topic"])
with pytest.raises(ValueError, match="unknown audience register"):
cli._audience_register_for_run(
args, {"LAST30DAYS_REGISTER": "board"}, None
)
with pytest.raises(SystemExit) as exc:
cli.build_parser().parse_args(["topic", "--register", "board"])
assert exc.value.code == 2
def test_unknown_configured_register_fails_before_retrieval(monkeypatch, capsys):
monkeypatch.setattr(
cli.env,
"get_config",
lambda **_kwargs: {"LAST30DAYS_REGISTER": "board"},
)
monkeypatch.setattr(
cli.pipeline,
"diagnose",
lambda *_args, **_kwargs: pytest.fail("retrieval preflight should not run"),
)
monkeypatch.setattr(sys, "argv", ["last30days.py", "test topic"])
assert cli.main() == 2
assert "unknown audience register 'board'" in capsys.readouterr().err
def test_creator_best_takes_honor_source_emphasis():
from lib import registers, render
audience = registers.get_register("creator")
assert audience.emphasis_weights, "creator preset must define emphasis weights"
# TikTok emphasis must exceed baseline sources like hackernews.
assert audience.emphasis_for("tiktok") > audience.emphasis_for("hackernews")
def test_best_takes_ranking_applies_source_weights():
from lib import render, schema
def candidate(cid, source, fun):
item = schema.SourceItem(
item_id=cid, source=source, title=f"take {cid}", body="b",
url=f"https://{source}/{cid}", published_at="2026-07-01",
snippet="s", engagement={"likes": 10},
)
return schema.Candidate(
candidate_id=cid, item_id=cid, source=source, title=f"take {cid}",
url=item.url, snippet="s", subquery_labels=["primary"],
native_ranks={f"primary:{source}": 1}, local_relevance=0.9,
freshness=90, engagement=10, source_quality=0.5, rrf_score=0.1,
final_score=90, cluster_id="cl", source_items=[item],
fun_score=80.0,
)
hn = candidate("hn1", "hackernews", 80.0)
tt = candidate("tt1", "tiktok", 80.0)
weights = {"tiktok": 1.5, "hackernews": 1.0}
lines = render._render_best_takes(
[hn, tt], limit=2, threshold=70.0,
source_weight=lambda source: weights.get(source, 1.0),
)
body = "\n".join(lines)
assert body.index("TikTok") < body.index("Hacker News") or body.index("tiktok") < body.index("hackernews") if "tiktok" in body.lower() else True
# Structural assertion: the tiktok take renders before the HN take.
tt_pos = body.lower().find("tiktok")
hn_pos = body.lower().find("hacker")
assert tt_pos != -1 and hn_pos != -1
assert tt_pos < hn_pos