A newsletter that runs itself

pip install noclick
export NOCLICK_API_KEY=nk_live_...
export EDITOR_EMAIL=you@example.com
export NEWSLETTER_DOMAIN=fieldnotes.example.com
python 06_multi_agent/newsletter_that_runs_itself/main.py        # set up, and show the latest issue
python 06_multi_agent/newsletter_that_runs_itself/main.py now    # write this week's issue now

import os
import sys
from pathlib import Path

import noclick

PUBLICATION_ID = "field-notes"  # your id for this publication
NAME = "Field Notes"
EDITOR_EMAIL = os.environ["EDITOR_EMAIL"]
DOMAIN = os.environ["NEWSLETTER_DOMAIN"]
TIMEZONE = "America/New_York"
SITE = Path(__file__).parent / "site"

SCHEMA = {
    "0001_newsletter.sql": """
create table subscribers (
    email text primary key,
    token text not null unique,
    created_at text not null default (datetime('now')),
    confirmed_at text
);
create table issues (
    slug text primary key,
    subject text not null,
    body text not null,
    published_at text not null default (datetime('now')),
    emailed_at text
);
""",
}


def open_database() -> noclick.Database:
    db = noclick.Database.from_name("newsletter", create_if_missing=True)
    db.migrate(SCHEMA)
    return db

POSTAL_ADDRESS = "Field Notes, 548 Market St #1123, San Francisco, CA 94104"


def deploy_site(db: noclick.Database) -> noclick.Project:
    repo = noclick.Repo.from_name("newsletter-site", create_if_missing=True)
    commit = repo.commit(SITE, message="Update the site", exclude=["node_modules", ".next"])

    app = noclick.Project.from_name("newsletter", repo=repo, framework="nextjs", create_if_missing=True)
    app.bind("DB", db)
    domain = app.add_domain(DOMAIN)
    app.email.enable(domain=DOMAIN, from_address=f"editor@{DOMAIN}", from_name=NAME, postal_address=POSTAL_ADDRESS)
    app.schedule(noclick.Cron("*/10 * * * *"), path="/jobs/send")
    if commit is not None or app.production is None:
        app.deploy().wait()

    for record in domain.refresh().records:
        if record.status != "verified":
            print(f"Add at your DNS host: {record.type} {record.name} {record.value}")
    return app

RESEARCHER = f"""You're the researcher for {NAME}, a weekly newsletter on climate tech for founders and investors.
When you're asked for this week's stories:
1. Find the week's most important climate tech news with exa.search: funding rounds over $10M, policy that
   changes what companies can sell, notable launches and large deployments. Read each source with fetch;
   prefer the company's own announcement plus one independent report.
2. Check the last four issues with query (select subject, body from issues order by slug desc limit 4) and
   drop anything they already covered.
3. Post a brief of the eight strongest stories: two or three sentences of facts each (who, what, how much,
   when) with the source links. End it with @writer.
Facts only. Leave out anything you couldn't source."""

WRITER = f"""You're the writer for {NAME}. When @researcher posts a brief, write this week's issue in Markdown:
- the subject line first, on a line of its own, under 60 characters
- two sentences on the week's biggest story
- five or six stories, each a bold headline and 60 to 90 words on what happened and why it matters to someone
  building or funding a climate company, with the source linked
- a one-line sign-off
Plain words, numbers with units, no hype and no exclamation marks. Post the whole issue and end it with
@editor. When @editor asks for changes, make them and post the whole issue again."""

EDITOR = f"""You're the editor of {NAME}. When @writer posts a draft:
1. Open every source with fetch and check each number and claim against it. Check the issue doesn't repeat
   the last one (query the issues table).
2. If anything is wrong, unsourced, over 900 words or off the house style, tell @writer exactly what to fix.
   Send it back at most twice; after that, fix it yourself.
3. When it's right, publish it with one execute:
   insert into issues (slug, subject, body) values (?, ?, ?)
   with this Monday's date as the slug (YYYY-MM-DD). The human editor approves it before it runs.
4. Post "Waiting for approval: <subject>". When you hear it ran, post "Published: https://{DOMAIN}/<slug>".
   If it's declined, post the note that came with it and send the issue back to @writer."""

def staff(name: str, instructions: str, tools: list) -> noclick.Agent:
    return noclick.Agent.from_name(
        name,
        create_if_missing=True,
        instructions=instructions,
        tools=tools,
        timezone=TIMEZONE,
    )


def open_newsroom(db: noclick.Database) -> noclick.Channel:
    researcher = staff("researcher", RESEARCHER, ["exa.search", "fetch", db.only("query")])
    writer = staff("writer", WRITER, [])
    editor = staff("editor", EDITOR, ["fetch", db.only("query", "execute")])
    return noclick.Channel.from_name(
        "newsroom",
        create_if_missing=True,
        members=[researcher, writer, editor],
        max_agent_turns=16,
        budget_usd=5,
        triggers=[noclick.Cron("0 6 * * 1", tz=TIMEZONE, message="@researcher Good morning. Find this week's stories.")],
    )

def set_rules(publication: noclick.User) -> None:
    noclick.Policy.set(user=publication, deny=["code"], require_approval=["database.execute"])

def write_now(room: noclick.Channel) -> None:
    kickoff = room.post("@researcher Find this week's stories.")
    for message in room.stream(after=kickoff):
        print(f"\n--- {message.author.name}\n{message.text}")
        if message.author.type == "system" or message.text.startswith("Waiting for approval"):
            break

def status(db: noclick.Database, app: noclick.Project, room: noclick.Channel) -> None:
    readers = db.query("select count(*) as n from subscribers where confirmed_at is not null").rows[0]["n"]
    print(f"\n{NAME} at {app.url}: {readers:,} confirmed signups")
    for issue in db.query("select slug, subject, emailed_at from issues order by slug desc limit 3"):
        print(f"  {issue['slug']}  {issue['subject']}  emailed {issue['emailed_at'] or 'not yet'}")
    for request in noclick.HumanRequest.list(status="pending", kind="approve"):
        print("Waiting for the human editor:", request.url)
    for trigger in room.triggers():
        print("Next issue starts:", trigger.next_run)
    used = app.usage()
    print(f"This month: ${noclick.usage().total_usd:.2f} in all, of which the site ${used.usd:.2f} for {used.requests:,} requests")

def main() -> None:
    publication = noclick.User.from_id(PUBLICATION_ID, create_if_missing=True, name=NAME, email=EDITOR_EMAIL)
    with noclick.as_user(publication):
        if sys.argv[1:] == ["stop"]:
            noclick.Channel.from_name("newsroom").close()
            return
        db = open_database()
        app = deploy_site(db)
        set_rules(publication)
        room = open_newsroom(db)
        if sys.argv[1:] == ["now"]:
            write_now(room)
        status(db, app, room)


if __name__ == "__main__":
    main()