edito

name	edito
description	Generate a daily French editorial synthesis of tech/AI news as a self-contained vintage newspaper HTML page. Uses deepsearch (SearXNG + Firecrawl) to scan curated sources, LiteLLM for AI-generated illustrations, and mermaid for data visualizations. Triggers on /skill:edito or when the user asks for a tech news summary, daily briefing, news roundup, or editorial synthesis.

Edito — Daily Tech & AI Editorial Synthesis

Produce a self-contained vintage newspaper-style HTML page summarizing today's tech and AI news from curated sources. Fully autonomous — one invocation, one output.

Invocation

• /skill:edito — today's edition, no focus
• /skill:edito [focus] — today's edition with thematic lens (e.g., "LLM agents", "Rust ecosystem")

Output

• File: ~/.pi/news/YYYY-MM-DD.html (today's date)
• Format: self-contained HTML (CSS inline, images as base64 data URIs)
• Language: French synthesis, tech names/projects kept in original language

Prerequisites — Read First

• references/sources.md — curated source list and scraping strategy
• assets/template.html — HTML/CSS template for the newspaper layout
• deepsearch skill — research engine (SearXNG + Firecrawl)

Workflow

Execute these steps autonomously without asking for confirmation.

Step 1 & 2 — Scan sources using deepsearch

Use the deepsearch skill (which handles auto-start, health checks, SearXNG discovery, and Firecrawl scraping) to research each source listed in references/sources.md.

For each source, use the appropriate strategy:

• Hacker News, Simon Willison, Mario Zechner, Science Étonnante, Tech Trash, GitHub Trending, HuggingFace Blog: use deepsearch's SearXNG + Firecrawl tools (discover, scrape, follow links)
• Developpez.com: use RSS feed (curl -sL "https://www.developpez.com/index/rss" → Python XML parsing). No Firecrawl needed.
• Google News FR Tech: use RSS feed (curl -sL "https://news.google.com/rss/topics/CAAqKggKIiRDQkFTRlFvSUwyMHZNRGRqTVhZU0JXWnlMVVpTR2dKR1VpZ0FQAQ?hl=fr&gl=FR&ceid=FR:fr" → Python XML parsing). No Firecrawl needed.
• The Neuron Daily: find today's newsletter post URL from the main page → scrape that specific post → extract ALL embedded article links and their summaries. The value is the curation.

See references/sources.md for detailed patterns and code snippets.

Rules:

• If a source is unreachable, skip it silently — never block the edition.
• At least 3 sources must return usable content. If fewer, report and stop.
• If a [focus] was given, weight results that match the focus topic.

Step 3 — Editorial synthesis

Organize findings by source — each source becomes a section:

1. For each successfully scraped source, write a synthesis of its key stories
2. Within each source section, highlight the 2-4 most significant items with editorial commentary
3. Add a brief chapeau (editorial lede) at the very top tying together the day's main thread
4. Write the synthesis in French, editorial style:
   • Per-source sections with analysis (not just summaries)
   • Use pull quotes for impactful statements from any source
   • GitHub trending as a dedicated ranked section

Article depth — two tiers:

Tier	Sources	Depth
Deep (reader must NOT need to click)	Hacker News, The Neuron Daily, Simon Willison, HuggingFace Blog, Tech Trash (+bonus), Mario Zechner, Science Étonnante, Developpez.com, Google Actualités FR	For each article: detailed and precise summary covering key points, main arguments, data/numbers, and conclusions. The reader must fully understand the topic without opening the link. Minimum 3-5 paragraphs per major article.
Light (list + brief overview)	GitHub Trending, arXiv — IA, GitHub — AI/Agents/MCP, GitHub — Écosystème Pi, HuggingFace Spaces, Twog (WTF)	Concise description: title, 1-2 sentences of context, link. List format is sufficient.

Deep tier workflow:

• Scrape each article individually via Firecrawl (not just the homepage)
• Read the full article content
• Write a structured summary in French capturing: context, main facts/arguments, key data, conclusion/impact
• The summary must be complete enough that the reader NEVER needs to open the original article
• The link remains present (for verification or further reading) but is no longer necessary for understanding

Section order (adapt if a source had no usable content):

1. Chapeau éditorial — 2-3 sentences connecting the day's main themes
2. Hacker News — top stories and discussion highlights
3. The Neuron Daily — today's newsletter only (all embedded articles + summaries)
4. Simon Willison — blog highlights
5. GitHub Trending — ranked repos list
6. HuggingFace Blog — today's community articles and official posts
7. Tech Trash — satirical take (FR) + "Bonus" items (quirky/absurd announcements)
8. Mario Zechner — coding agent insights
9. Science Étonnante — vulgarisation scientifique FR (David Louapre) — substack + blog
10. Developpez.com — francophone dev news (top 5 via RSS)
11. Google Actualités FR — tech headlines only (top 5 via RSS)

Following the news, the Research & Exploration sections (separate):

11. arXiv — Intelligence Artificielle — 5 papers récents (AI general: agents, LLM, code generation, memory, planning)
12. GitHub — AI, Agents & MCP — 5 repos (queries: AI agent, MCP, agent memory, knowledge graph, agentic)
13. GitHub — Écosystème Pi — 3 repos (pi coding agent, pi-coding-agent, earendil, .pi/agent)
14. HuggingFace Spaces — 5 trending spaces of the week

Après la recherche, la section WTF :

15. Twog — 3 posts aléatoires du jour depuis twog.fr (humour, débats absurdes, faits divers improbables)

Style directives:

• Tone: informed, opinionated, slightly literary — like a tech columnist who reads widely
• Avoid: bullet lists, jargon dumps, press release rewrites
• Prefer: narrative flow, connecting dots between stories, historical context when relevant
• First paragraphs get drop caps (handled by CSS template)
• Each source section gets a header with the source name
• Links: every article/story mentioned MUST include a clickable link to the original (target="_blank")
• Depth (Deep tier): each article summary must be a self-contained read. The reader should finish the summary feeling informed — not curious to click. Include key arguments, data points, quotes, and conclusions. Write 3-5 paragraphs per major article. Think "full synthesis" not "teaser".
• Depth (Light tier): concise descriptions, 1-2 sentences max. The link is the point.
• Research section: concise and technical. Each item = paper/repo title + one-paragraph synthesis of what it does and why it matters for agent development. Include links to papers/repos.

Step 4 — Visuals (optional)

No AI-generated illustrations — they don't add editorial value. Skip image generation entirely.

Mermaid diagrams — only when data strongly justifies it (e.g., timeline of events, market share comparison). Use the mermaid skill to generate SVG, then inline it in the HTML. This is rare — most editions won't need one.

Step 5 — Assemble HTML

Use the assembler script at scripts/assemble.py to avoid output token limits.

1. Write the editorial content as a JSON file to /tmp/edito_content.json following this structure:

{
  "chapeau": "Editorial lede text...",
  "sources_unavailable": ["Developpez.com (GDPR wall)"],
  "sections": [
    {
      "source": "Hacker News",
      "layout": "columns-3",
      "articles": [
        {
          "headline": "Title",
          "headline_class": "major",
          "byline": "869 points — 534 comments",
          "url": "https://...",
          "body": "<p>First paragraph...</p><p>Second...</p>"
        }
      ],
      "pull_quote": "Optional quote..."
    },
    {
      "source": "GitHub Trending",
      "layout": "columns-2",
      "trending_list": [
        {"name": "user/repo", "description": "...", "stars": "1,234 ⭐/jour", "url": "https://github.com/user/repo"}
      ],
      "articles": [{"headline": "Analyse", "body": "<p>...</p>"}]
    }
  ]
}

2. Run the assembler:

python3 ~/.pi/agent/skills/edito/scripts/assemble.py \
  --date "Mercredi 28 mai 2026" \
  --output ~/.pi/news/2026-05-28.html \
  --content /tmp/edito_content.json

Critical — Chunking strategy to avoid token limit crashes:

1. Write each source section as a separate JSON file in /tmp/edito_parts/ (e.g., 01_hn.json, 02_neuron.json...)
2. Write a 00_meta.json with chapeau and sources_unavailable
3. Run a Python assembler to merge all parts into /tmp/edito_content.json
4. Then run the HTML assembler script

Never try to output the full JSON or HTML in a single response — it will exceed token limits and crash.

Layout rules:

• Hacker News: columns-3 (many stories)
• The Neuron Daily: columns-2
• Simon Willison: single (deep editorial)
• GitHub Trending: columns-2 (trending_list + analysis article)
• HuggingFace Blog: columns-2
• Tech Trash: single (deep editorial)
• Developpez.com: columns-2
• Mario Zechner: single
• Science Étonnante: single
• Google News FR: columns-2
• arXiv — Intelligence Artificielle: single (papers need space for abstracts)
• GitHub — AI, Agents & MCP: columns-2
• GitHub — Écosystème Pi: single
• HuggingFace Spaces: columns-2
• Twog (WTF): single

Step 6 — Write output

mkdir -p ~/.pi/news

Write the assembled HTML to ~/.pi/news/YYYY-MM-DD.html (using today's date).

Step 7 — Open in browser

open ~/.pi/news/YYYY-MM-DD.html

Step 8 — Update local index

python3 -c "
import json
from pathlib import Path
import re

news_dir = Path.home() / '.pi' / 'news'
index_path = news_dir / 'index.json'
index = json.loads(index_path.read_text()) if index_path.exists() else []

# Add today's edition
html_path = news_dir / 'YYYY-MM-DD.html'
content = html_path.read_text()
chapeau = re.search(r'<p class=\"chapeau\">(.*?)</p>', content, re.DOTALL)
sources = re.search(r'Sources : (.*?)</p>', content)

entry = {
    'date': 'YYYY-MM-DD',
    'path': str(html_path),
    'size_bytes': html_path.stat().st_size,
    'chapeau': (chapeau.group(1).strip()[:200] if chapeau else ''),
    'sources': (sources.group(1).strip() if sources else '')
}

# Replace if same date exists
index = [e for e in index if e['date'] != entry['date']]
index.append(entry)
index.sort(key=lambda e: e['date'])
index_path.write_text(json.dumps(index, ensure_ascii=False, indent=2))
print(f'Index updated: {len(index)} editions')
"

The index lives at ~/.pi/news/index.json — a simple JSON array with date, path, chapeau summary, and sources. No Neo4j pollution. Search past editions with grep -r "keyword" ~/.pi/news/ or read the index file.

Key Principles

• Autonomous: no intermediate questions, no confirmation prompts
• Editorial over informational: synthesis with opinion, not a link dump
• Graceful degradation: missing sources or failed images never block the edition
• Self-contained output: the HTML file works offline, no external dependencies at render time
• Lightweight memory: local index.json only — no Neo4j facts for editions (avoids polluting work-session recall)