#!/usr/bin/env python3 """Export README resource entries as tabular dataset files.""" from __future__ import annotations import argparse import csv import json import re import sys from pathlib import Path from tempfile import TemporaryDirectory from urllib.parse import urlparse ROOT = Path(__file__).resolve().parents[1] README = ROOT / "README.md" CSV_PATH = ROOT / "data" / "resources.csv" JSONL_PATH = ROOT / "data" / "resources.jsonl" SITE_JSON_PATH = ROOT / "docs" / "assets" / "resources.json" AUDIT_PATH = ROOT / "data" / "resource_source_audit.csv" FIRST_SEEN_PATH = ROOT / "data" / "first_seen.json" SOURCE_URL = "https://github.com/ChaoYue0307/awesome-loop-engineering/blob/main/README.md" PROJECT_GITHUB_REPO = "chaoyue0307/awesome-loop-engineering" def load_first_seen() -> dict[str, str]: """url -> ISO date the entry was first added. Forward-only; empty for entries that predate per-entry date tracking (which began 2026-07-15).""" if FIRST_SEEN_PATH.exists(): return json.loads(FIRST_SEEN_PATH.read_text(encoding="utf-8")) return {} FIRST_SEEN = load_first_seen() ENTRY_RE = re.compile( r"^- (?P\S+) \*\*(?P[^*]+)\*\* " r"\[(?P[^\]]+)\]\((?P<url>[^)]+)\) - (?P<annotation>.+)$" ) TABLE_ENTRY_RE = re.compile( r"^\| (?P<marker>\S+) \*\*\[(?P<title>[^\]]+)\]\((?P<url>[^)]+)\)\*\*" r"<br><sub>(?P<resource_type>[^<]+)</sub>\s+\| (?P<metadata>.*?) \| " r"(?P<annotation>.*?) \| (?P<table_evidence>.+) \|$" ) LEGACY_TABLE_ENTRY_RE = re.compile( r"^\| (?P<marker>\S+) \*\*\[(?P<title>[^\]]+)\]\((?P<url>[^)]+)\)\*\*" r"<br><sub>(?P<resource_type>[^<]+)</sub>\s+\| (?P<metadata>.*?) \| " r"(?P<annotation>.+) \|$" ) HEADING_RE = re.compile(r"^(?P<level>#{2,3}) (?P<title>.+)$") NON_SLUG_RE = re.compile(r"[^a-z0-9]+") TYPE_MARKERS = { "Paper": "๐Ÿ“„", "Blog": "๐Ÿ“", "Docs": "๐Ÿ“š", "Tool": "๐Ÿงฐ", "Benchmark": "๐Ÿงช", "Pattern": "๐Ÿ”", "Template": "๐Ÿงพ", "List": "๐Ÿงญ", "Critique": "โš ๏ธ", } def base_resource_type(value: str) -> str: cleaned = clean(value) return next( ( resource_type for resource_type in TYPE_MARKERS if cleaned == resource_type or cleaned.startswith(f"{resource_type} ยท") ), cleaned, ) FIELDS = [ "row_id", "section", "section_slug", "resource_type", "marker", "title", "url", "url_kind", "domain", "annotation", "description", "key_contribution", "novelty", "impact", "signal", "signal_strength", "source_readme", "source_line", "source_url", "date_added", "collection", "collection_slug", "user_goal", "lifecycle_stages", "audience", "loop_layer", "scope_fit", "evidence_class", "evidence_tier", "source_status", "canonical_url", "source_title", "source_description", "authors", "publication_date", "publication_year", "publication_venue", "publisher", "doi", "publication_note", "primary_category", "metadata_source", "github_repo", "github_stars", "github_forks", "github_license", "github_created_at", "github_updated_at", "arxiv_id", "audited_at", ] SITE_FIELDS = [ "row_id", "title", "url", "canonical_url", "annotation", "key_contribution", "novelty", "impact", "signal", "resource_type", "collection", "user_goal", "section", "section_slug", "lifecycle_stages", "audience", "loop_layer", "scope_fit", "evidence_class", "evidence_tier", "signal_strength", "source_status", "authors", "publication_date", "publication_year", "publication_venue", "publisher", "doi", "publication_note", "primary_category", "metadata_source", "github_repo", "github_stars", "arxiv_id", "date_added", ] COLLECTIONS = { "Concept Guides": ("Learn", "Understand the field and its boundaries."), "Start Here": ("Learn", "Understand the field and its boundaries."), "Research Foundations": ("Learn", "Understand the field and its boundaries."), "Model-Level Recurrence": ("Learn", "Understand how recurrent model computation can power, but not replace, a governed agent loop."), "Pattern Library": ("Design", "Specify a loop contract and operating pattern."), "Core Loop Primitives": ("Design", "Specify a loop contract and operating pattern."), "Agent Workflow Patterns": ("Design", "Specify a loop contract and operating pattern."), "Official Runtime Guides": ("Build", "Choose runtimes, tools, and delegation surfaces."), "Coding-Agent Loop Systems": ("Build", "Choose runtimes, tools, and delegation surfaces."), "Orchestration And Multi-Agent Delegation": ("Build", "Choose runtimes, tools, and delegation surfaces."), "State, Memory, And Context Persistence": ("Persist", "Carry context, state, and receipts across runs."), "Verification And Feedback Gates": ("Verify", "Gate progress with tests, evals, and evidence."), "Benchmarks And Evaluation": ("Verify", "Gate progress with tests, evals, and evidence."), "Securing Unattended Loops": ("Govern", "Bound permissions, cost, failure, and escalation."), "Operations Playbooks": ("Govern", "Bound permissions, cost, failure, and escalation."), "Critiques, Risks, And Limitations": ("Govern", "Bound permissions, cost, failure, and escalation."), "Templates And Patterns": ("Apply", "Reuse, adapt, and contribute concrete loop artifacts."), "Examples And Schema": ("Apply", "Reuse, adapt, and contribute concrete loop artifacts."), "Community Gallery": ("Apply", "Reuse, adapt, and contribute concrete loop artifacts."), "Adjacent Awesome Lists": ("Apply", "Reuse, adapt, and contribute concrete loop artifacts."), "Explore And Reuse": ("Apply", "Reuse, adapt, and contribute concrete loop artifacts."), "Shape What Comes Next": ("Apply", "Reuse, adapt, and contribute concrete loop artifacts."), } COLLECTION_IMPACT = { "Learn": "understand the evidence, vocabulary, and lineage behind recurring agent systems", "Design": "turn a recurring-agent idea into an explicit loop contract", "Build": "choose an implementation surface for repeatable agent work", "Persist": "carry context, state, and receipts across runs and failures", "Verify": "measure progress and gate completion with repeatable evidence", "Govern": "bound risk before recurring or unattended execution", "Apply": "reuse a concrete artifact or connect it to the wider ecosystem", } SECTION_STAGE_DEFAULTS = { "Concept Guides": ["whole-loop"], "Start Here": ["whole-loop"], "Pattern Library": ["whole-loop"], "Research Foundations": ["whole-loop"], "Model-Level Recurrence": ["act"], "Official Runtime Guides": ["workspace", "context", "delegation", "state"], "Agent Workflow Patterns": ["delegation", "verification"], "Coding-Agent Loop Systems": ["workspace", "delegation", "verification", "state"], "Verification And Feedback Gates": ["verification"], "Securing Unattended Loops": ["workspace", "budget", "escalation"], "State, Memory, And Context Persistence": ["context", "state"], "Orchestration And Multi-Agent Delegation": ["delegation", "state"], "Benchmarks And Evaluation": ["verification"], "Operations Playbooks": ["trigger", "intake", "budget", "escalation", "exit"], "Critiques, Risks, And Limitations": ["budget", "escalation", "exit"], "Templates And Patterns": ["whole-loop"], "Examples And Schema": ["whole-loop"], "Community Gallery": ["whole-loop"], } STAGE_RULES = [ ("objective", r"\bobjective(?:s)?\b|\bgoal(?:s)?\b|success criteria"), ("trigger", r"\btrigger(?:s|ed)?\b|\bschedul(?:e|ed|ing)\b|\bcadence\b|\bcron\b|\bevent-driven\b"), ("intake", r"\bintake\b|\bqueue(?:s)?\b|\bdiscover(?:y|s|ed)?\b|\btriage\b|\bissue(?:s)?\b"), ("workspace", r"\bworkspace(?:s)?\b|\bworktree(?:s)?\b|\bsandbox(?:es|ed|ing)?\b|\bpermission(?:s)?\b|\btool(?:s)?\b"), ("context", r"\bcontext\b|\bmemory\b|\bmemories\b|\bretrieval\b|\bdocument(?:s)?\b"), ("delegation", r"\bdelegat(?:e|es|ed|ion)\b|\bmulti-agent\b|\bsubagent(?:s)?\b|\bhandoff(?:s)?\b|\borchestrat(?:e|es|ed|ion|or|ors)\b"), ("verification", r"\bverif(?:y|ies|ied|ication)\b|\beval(?:s|uation)?\b|\btest(?:s|ed|ing)?\b|\bbenchmark(?:s)?\b|\bgrader(?:s)?\b|\bcritic(?:s)?\b"), ("state", r"\bstate(?:ful)?\b|\bpersist(?:s|ed|ence|ent)?\b|\bcheckpoint(?:s|ed|ing)?\b|\breplay\b|\breceipt(?:s)?\b"), ("budget", r"\bbudget(?:s)?\b|\bcost(?:s)?\b|\btoken(?:s)?\b|\bretr(?:y|ies)\b|\btimeout(?:s)?\b"), ("escalation", r"\bescalat(?:e|es|ed|ion)\b|\bhuman(?:-in-the-loop)?\b|\bapproval(?:s)?\b|\bhandoff\b"), ("exit", r"\bexit\b|\bstop(?:s|ped|ping)?\b|\bcompletion\b|\bdone\b|\btermination\b"), ] OFFICIAL_DOC_DOMAINS = { "adk.dev", "learn.chatgpt.com", "code.claude.com", "docs.crewai.com", "docs.anthropic.com", "docs.github.com", "docs.langchain.com", "developers.openai.com", "learn.microsoft.com", "modelcontextprotocol.io", "opentelemetry.io", "openai.github.io", "strandsagents.com", } SECTION_IMPACT = { "Concept Guides": "Clarifies the scope, vocabulary, and boundaries of Loop Engineering for recurring, stateful, verified agent systems.", "Start Here": "Gives readers the origin story and first-principles framing for the new AI/coding-agent use of Loop Engineering.", "Core Loop Primitives": "Turns the concept into concrete loop mechanics: triggers, state, tools, worktrees, permissions, and recurring execution.", "Official Runtime Guides": "Anchors implementation choices in primary vendor and framework documentation instead of second-hand summaries.", "Research Foundations": "Connects Loop Engineering to prior work on agent loops, planning, reflection, feedback, and long-horizon autonomy.", "Model-Level Recurrence": "Explains the inner recurrent computation that can improve an agent's model while remaining distinct from the outer operating loop.", "Agent Workflow Patterns": "Shows reusable architecture patterns that compose agents, evaluators, workers, and durable workflow control.", "Coding-Agent Loop Systems": "Grounds the practice in real coding-agent systems, bare loops, orchestration tools, and long-running software tasks.", "Verification And Feedback Gates": "Identifies the feedback signals that make recurring agent work measurable, retryable, and safe to stop.", "Securing Unattended Loops": "Surfaces the security boundaries needed when loops ingest untrusted content or act without constant human supervision.", "State, Memory, And Context Persistence": "Explains how loop state survives across runs through memory, checkpointers, progress files, and context management.", "Orchestration And Multi-Agent Delegation": "Maps the runtimes and coordination patterns used to split loop work across specialized agents and durable workflows.", "Benchmarks And Evaluation": "Provides measurement targets for long-horizon, tool-using, coding, web, and terminal agents.", "Operations Playbooks": "Collects practitioner workflows for running agents as delegated work systems rather than isolated prompts.", "Templates And Patterns": "Provides reusable artifacts that builders can adapt into loop specs, resources, and examples.", "Examples And Schema": "Makes the loop contract executable and portable through validated JSON examples and runnable reference loops.", "Community Gallery": "Gives contributors a format for publishing real or anonymized loop cases with receipts and lessons learned.", "Explore And Reuse": "Makes the evidence browsable, queryable, and reusable across interactive and machine-readable formats.", "Shape What Comes Next": "Connects open questions, planned work, community feedback, and operating case studies.", "Pattern Library": "Translates the abstract loop contract into operational patterns with triggers, gates, budgets, and escalation paths.", "Critiques, Risks, And Limitations": "Preserves cautionary evidence so adoption stays proportional to task risk, signal quality, and economics.", "Adjacent Awesome Lists": "Connects readers to neighboring ecosystems while keeping Loop Engineering's scope distinct.", } SECTION_NOVELTY = { "Start Here": "Captures the early community framing of Loop Engineering as repeated agent delegation rather than prompt craft.", "Core Loop Primitives": "Breaks loop design into operational primitives that can be combined across agents and runtimes.", "Official Runtime Guides": "Shows how production platforms expose loops through concrete tools, permissions, skills, agents, and automation features.", "Agent Workflow Patterns": "Distills reusable agent-control patterns that are not tied to a single vendor implementation.", "Coding-Agent Loop Systems": "Uses real automated software-engineering systems as evidence for practical loop architectures.", "Verification And Feedback Gates": "Treats feedback, telemetry, and deterministic artifacts as loop-control gates.", "Securing Unattended Loops": "Frames security as a recurring-loop boundary rather than a one-time prompt hygiene issue.", "State, Memory, And Context Persistence": "Makes persistence and context management visible as runtime design choices.", "Orchestration And Multi-Agent Delegation": "Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop.", "Benchmarks And Evaluation": "Links loop design to measurable tasks where progress and failure can be compared.", "Operations Playbooks": "Translates agent-loop ideas into operator-facing workflows for repeated delegated work.", "Templates And Patterns": "Turns the concept into reusable specifications, checklists, and operating patterns.", "Examples And Schema": "Makes loop contracts portable and validation-friendly through concrete examples.", "Community Gallery": "Turns loop adoption into shareable cases with enough structure to compare lessons learned.", "Explore And Reuse": "Turns the evidence into an interactive atlas and structured data.", "Shape What Comes Next": "Turns open questions and operating lessons into visible next work.", "Pattern Library": "Turns common recurring-agent jobs into named patterns with gates, budgets, and escalation paths.", "Critiques, Risks, And Limitations": "Keeps adoption grounded in known failure modes, economics, and operational limits.", "Adjacent Awesome Lists": "Connects neighboring ecosystems while preserving Loop Engineering as a narrower operating concept.", "Model-Level Recurrence": "Separates shared-block latent iteration inside one model inference from repeated, externally governed agent work.", } SECTION_LOOP_LAYERS = { "Concept Guides": "cross-layer", "Start Here": "cross-layer", "Pattern Library": "workflow", "Core Loop Primitives": "workflow", "Official Runtime Guides": "harness", "Research Foundations": "cross-layer", "Model-Level Recurrence": "model", "Agent Workflow Patterns": "workflow", "Coding-Agent Loop Systems": "agent", "Verification And Feedback Gates": "harness", "Securing Unattended Loops": "operations", "State, Memory, And Context Persistence": "harness", "Orchestration And Multi-Agent Delegation": "workflow", "Benchmarks And Evaluation": "evaluation", "Operations Playbooks": "operations", "Templates And Patterns": "workflow", "Examples And Schema": "workflow", "Community Gallery": "operations", "Critiques, Risks, And Limitations": "cross-layer", "Adjacent Awesome Lists": "cross-layer", "Explore And Reuse": "cross-layer", "Shape What Comes Next": "cross-layer", } TITLE_LOOP_LAYERS = { "Awesome Loop Models": "model", } DIRECT_SCOPE_SECTIONS = { "Concept Guides", "Start Here", "Pattern Library", "Core Loop Primitives", "Coding-Agent Loop Systems", "Operations Playbooks", "Templates And Patterns", "Examples And Schema", "Community Gallery", } ADJACENT_SCOPE_SECTIONS = {"Model-Level Recurrence", "Adjacent Awesome Lists"} TYPE_SIGNAL = { "Paper": ("Research paper or preprint; strongest signal when the entry contributes a method, benchmark, measurement, or formal framing.", "high"), "Docs": ("Primary documentation from a platform, SDK, standard, or framework; strong implementation signal.", "high"), "Tool": ("Working implementation, framework, runtime, or repository; signal comes from usable code and ecosystem adoption.", "high"), "Benchmark": ("Evaluation artifact or leaderboard; signal comes from measurable tasks and repeatable scoring.", "high"), "Pattern": ("Operational pattern or playbook; signal comes from reusable loop structure and practical transferability.", "medium"), "Template": ("Reusable template, schema, checklist, or guide; signal comes from concrete adaptation and validation.", "medium"), "Blog": ("Practitioner essay or field note; signal comes from concrete experience, framing, examples, or adoption discussion.", "contextual"), "Critique": ("Risk or limitation analysis; signal comes from boundary conditions, failure modes, and adoption cautions.", "contextual"), "List": ("Adjacent directory or reading list; signal comes from ecosystem coverage rather than a single technical claim.", "contextual"), } EVIDENCE_TIERS = { "research-paper": "A", "research-preprint": "A", "official-documentation": "A", "technical-documentation": "A", "source-implementation": "A", "implementation": "A", "benchmark": "A", "repository-native": "A", "reusable-artifact": "A", "operational-pattern": "B", "practitioner-analysis": "B", "risk-analysis": "B", "curated-index": "C", "curated-source": "C", } NOVELTY_RULES = [ (r"\bofficial\b|\bprimary-source\b", "Primary-source operational guidance rather than commentary."), (r"\bfuture directions?\b|\bresearch agenda\b", "Turns open gaps into measurable research, infrastructure, and product directions."), (r"\bdurable\b|\breplay\b", "Durable execution and replay are treated as first-class loop infrastructure."), (r"\bcheckpoint(?:ing|ed|s)?\b", "Checkpointed state makes long-running agent work recoverable across failures."), (r"\bworktree(?:s)?\b", "Workspace isolation is part of the loop design, not an afterthought."), (r"\bdataset\b|\bresources\.csv\b|\bresources\.jsonl\b", "Packages the evidence as queryable CSV and JSONL rather than only a rendered page."), (r"\bdag(?:s)?\b|\bgraph(?:s)?\b", "Control flow is represented as an inspectable graph rather than an opaque prompt loop."), (r"\bschedule(?:d|s)?\b|\bscheduling\b|\bcadence\b", "The trigger or cadence is explicit, making the workflow recurring rather than one-off."), (r"\bself-verification\b|\bself-verifying\b", "The agent workflow includes explicit self-checking or gated completion."), (r"\bverification\b|\bverifier\b|\bverified\b", "Verification is promoted from a final check to a loop-control signal."), (r"\beval(?:s|uation)?\b|\bgrader(?:s)?\b", "Evaluation data is used as the feedback signal for improving loop behavior."), (r"\bbenchmark(?:s)?\b|\bleaderboard\b", "The work turns loop quality into a measurable task or score."), (r"\bmemory\b|\bmemories\b", "Persistent memory is treated as an external runtime artifact."), (r"\bcontext\b|\bcontext-window\b", "Context is managed as durable loop state rather than a single prompt payload."), (r"\bmulti-agent\b|\bsubagent(?:s)?\b", "The work separates roles across agents, verifiers, or orchestration layers."), (r"\borchestrat(?:e|es|ed|ion|or|ors)\b", "Orchestration and control flow are made explicit and inspectable."), (r"\bsandbox(?:es|ed|ing)?\b", "Execution isolation and permission boundaries are part of the design."), (r"\bprompt injection\b|\buntrusted\b", "Untrusted intake is treated as a loop-level security boundary."), (r"\blong-horizon\b|\bmulti-hour\b|\bcontext window(?:s)?\b", "The work targets tasks that exceed a single context window or prompt session."), (r"\bstate\b|\bstateful\b|\bpersist(?:s|ed|ent|ence)?\b", "State persistence is explicit enough for repeated runs and handoff."), (r"\bschema\b|\bjson\b|\bmachine-readable\b", "The contribution is machine-readable and validation-friendly."), (r"\btemplate\b|\bchecklist\b|\bguide\b", "The resource is directly reusable as a starting artifact."), ] def slugify(value: str) -> str: slug = NON_SLUG_RE.sub("-", value.lower()).strip("-") return slug or "section" def clean(value: str) -> str: return " ".join(value.strip().split()) def parse_entry_line(raw_line: str) -> dict[str, str] | None: """Parse the legacy list syntax or the current tabular resource-row syntax.""" match = ENTRY_RE.match(raw_line) if match: return match.groupdict() match = TABLE_ENTRY_RE.match(raw_line) or LEGACY_TABLE_ENTRY_RE.match(raw_line) if not match: return None entry = match.groupdict() for field in ("title", "url", "annotation"): entry[field] = entry[field].replace(r"\|", "|") return entry def classify_url(url: str) -> tuple[str, str]: parsed = urlparse(url) if parsed.scheme in {"http", "https"}: return "external", parsed.netloc.lower() if url.startswith("#"): return "local_anchor", "" return "local_path", "" def publication_source( url: str, url_kind: str, domain: str, audit: dict[str, str], ) -> tuple[str, str]: """Return the original publishing surface without using this project as a venue.""" if audit.get("publication_venue") and audit.get("publisher"): return audit["publication_venue"], audit["publisher"] if url_kind != "external": return "GitHub", "GitHub" github_repo = audit.get("github_repo", "").lower() if github_repo == PROJECT_GITHUB_REPO: path = urlparse(url).path.lower() if "/releases" in path: return "GitHub Releases", "GitHub" if "/discussions" in path: return "GitHub Discussions", "GitHub" return "GitHub", "GitHub" venue = audit.get("publication_venue", "") publisher = audit.get("publisher", "") or domain or "Source not stated" return venue, publisher def load_audit() -> dict[str, dict[str, str]]: if not AUDIT_PATH.exists(): return {} with AUDIT_PATH.open(encoding="utf-8", newline="") as handle: return {row["url"]: row for row in csv.DictReader(handle)} AUDIT_BY_URL = load_audit() def key_contribution(annotation: str) -> str: return clean(annotation).rstrip(".") + "." def novelty(section: str, title: str, annotation: str) -> str: if section == "Concept Guides": lens = "Makes an otherwise informal practice concrete and reusable." return f"{lens} {key_contribution(annotation)}" if section == "Model-Level Recurrence": lens = "Reuses learned computation inside one model inference rather than repeating a full agent run." return f"{lens} {key_contribution(annotation)}" text = f"{title} {annotation}".lower() for pattern, phrase in NOVELTY_RULES: if re.search(pattern, text): return f"{phrase} {key_contribution(annotation)}" if section in {"Concept Guides", "Templates And Patterns", "Examples And Schema"}: lens = "Makes an otherwise informal practice concrete and reusable." elif section == "Research Foundations": lens = "Connects Loop Engineering to prior agent-loop and feedback-loop research." else: lens = SECTION_NOVELTY.get(section, "Contributes a distinct loop-engineering angle beyond a generic agent resource.") return f"{lens} {key_contribution(annotation)}" def collection_for(section: str) -> tuple[str, str]: return COLLECTIONS.get(section, ("Apply", "Reuse, adapt, and contribute concrete loop artifacts.")) def lifecycle_stages(section: str, title: str, annotation: str) -> str: text = f"{title} {annotation}".lower() stages = [stage for stage, pattern in STAGE_RULES if re.search(pattern, text)] if section == "Model-Level Recurrence" and "act" not in stages: stages.insert(0, "act") if not stages: stages = SECTION_STAGE_DEFAULTS.get(section, ["whole-loop"]) return ";".join(dict.fromkeys(stages)) def audience_for(section: str, resource_type: str) -> str: audiences: list[str] = [] if section in {"Concept Guides", "Start Here"}: audiences.append("newcomer") if resource_type in {"Docs", "Tool", "Pattern", "Template"}: audiences.append("builder") if resource_type in {"Paper", "Benchmark"}: audiences.extend(["researcher", "evaluator"]) if section == "Model-Level Recurrence": audiences.extend(["model-builder", "agent-builder"]) if section in {"Securing Unattended Loops", "Operations Playbooks", "Critiques, Risks, And Limitations"}: audiences.extend(["operator", "security"]) if section in {"Verification And Feedback Gates", "Benchmarks And Evaluation"}: audiences.append("evaluator") if section in {"Templates And Patterns", "Examples And Schema", "Community Gallery"}: audiences.extend(["builder", "operator"]) return ";".join(dict.fromkeys(audiences or ["builder"])) def evidence_class( section: str, resource_type: str, domain: str, url_kind: str, audit: dict[str, str], ) -> str: if url_kind != "external" and resource_type == "Paper" and audit.get("publication_venue"): return "research-preprint" if url_kind != "external": return "repository-native" if resource_type == "Benchmark": return "benchmark" if resource_type == "Docs" and (section == "Official Runtime Guides" or domain in OFFICIAL_DOC_DOMAINS): return "official-documentation" if domain == "arxiv.org": venue = audit.get("publication_venue", "").strip().lower() publisher = audit.get("publisher", "").strip().lower() return "research-preprint" if venue in {"", "arxiv"} or publisher == "arxiv" else "research-paper" if domain == "github.com" and resource_type == "Tool": return "source-implementation" return { "Paper": "research-paper", "Docs": "technical-documentation", "Tool": "implementation", "Pattern": "operational-pattern", "Template": "reusable-artifact", "Blog": "practitioner-analysis", "Critique": "risk-analysis", "List": "curated-index", }.get(resource_type, "curated-source") def loop_layer(section: str, title: str) -> str: return TITLE_LOOP_LAYERS.get(title, SECTION_LOOP_LAYERS.get(section, "cross-layer")) def scope_fit(section: str) -> str: if section in ADJACENT_SCOPE_SECTIONS: return "adjacent" if section in DIRECT_SCOPE_SECTIONS: return "direct" return "enabling" def impact(collection: str, section: str, title: str) -> str: if section == "Model-Level Recurrence": return f"Use {title} to assess inner latent computation as a model capability inside a separately governed agent loop." goal = COLLECTION_IMPACT.get(collection, "apply the source to a recurring agent system") return f"Use {title} to {goal}." def evidence_tier(evidence: str) -> str: return EVIDENCE_TIERS.get(evidence, "C") def format_count(value: str) -> str: try: return f"{int(value):,}" except (TypeError, ValueError): return "" def signal( resource_type: str, domain: str, url_kind: str, evidence: str, audit: dict[str, str], ) -> tuple[str, str]: status = audit.get("audit_status", "") if status in {"broken", "unreachable", "local_missing"}: return "The linked source was unavailable at the latest check; treat its claims and availability as unverified.", "unverified" if evidence == "official-documentation": return f"Primary official documentation from {domain}; use it for current product or standard behavior.", "high" if evidence in {"research-preprint", "research-paper"}: arxiv_id = audit.get("arxiv_id", "") identifier = f" arXiv:{arxiv_id}" if arxiv_id else "" return f"Research source{identifier}; inspect its method and evaluation before treating results as production evidence.", "medium" if url_kind != "external": return "Repository file; inspect the linked schema, example, guide, or implementation.", "medium" if evidence == "benchmark": return "Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.", "high" if domain == "github.com": stars = format_count(audit.get("github_stars", "")) forks = format_count(audit.get("github_forks", "")) license_id = audit.get("github_license", "") updated = audit.get("github_updated_at", "")[:10] facts = [] if stars: facts.append(f"{stars} stars") if forks: facts.append(f"{forks} forks") if license_id: facts.append(f"{license_id} license") if updated: facts.append(f"updated {updated}") detail = f" ({'; '.join(facts)})" if facts else "" return f"Inspectable GitHub source{detail}; popularity is context, not proof of reliability.", "medium" if evidence in {"practitioner-analysis", "risk-analysis", "curated-index"}: return f"Contextual source from {domain}; useful for practice signals or boundary conditions, not independent validation.", "contextual" return TYPE_SIGNAL.get(resource_type, (f"Background source from {domain}; verify fit against the linked artifact.", "contextual")) def iter_rows(readme_path: Path = README) -> list[dict[str, str]]: section = "" section_slug = "" rows: list[dict[str, str]] = [] for line_number, raw_line in enumerate(readme_path.read_text(encoding="utf-8").splitlines(), 1): heading = HEADING_RE.match(raw_line) if heading: if heading.group("level") == "##": section = clean(heading.group("title")) section_slug = slugify(section) continue entry = parse_entry_line(raw_line) if not entry: continue url = clean(entry["url"]) if "example.com" in url: continue url_kind, domain = classify_url(url) annotation = clean(entry["annotation"]) resource_type = base_resource_type(entry["resource_type"]) row_number = len(rows) + 1 row_id = f"ale-{row_number:04d}" collection, user_goal = collection_for(section) audit = AUDIT_BY_URL.get(url, {}) evidence = evidence_class(section, resource_type, domain, url_kind, audit) signal_text, signal_strength = signal(resource_type, domain, url_kind, evidence, audit) publication_venue, publisher = publication_source(url, url_kind, domain, audit) rows.append( { "row_id": row_id, "section": section, "section_slug": section_slug, "resource_type": resource_type, "marker": clean(entry["marker"]), "title": clean(entry["title"]), "url": url, "url_kind": url_kind, "domain": domain, "annotation": annotation, "description": annotation, "key_contribution": key_contribution(annotation), "novelty": novelty(section, clean(entry["title"]), annotation), "impact": impact(collection, section, clean(entry["title"])), "signal": signal_text, "signal_strength": signal_strength, "source_readme": "README.md", "source_line": line_number, "source_url": f"{SOURCE_URL}#L{line_number}", "date_added": FIRST_SEEN.get(url, ""), "collection": collection, "collection_slug": slugify(collection), "user_goal": user_goal, "lifecycle_stages": lifecycle_stages(section, clean(entry["title"]), annotation), "audience": audience_for(section, resource_type), "loop_layer": loop_layer(section, clean(entry["title"])), "scope_fit": scope_fit(section), "evidence_class": evidence, "evidence_tier": evidence_tier(evidence), "source_status": audit.get("audit_status", "not-audited"), "canonical_url": audit.get("canonical_url", "") or audit.get("final_url", "") or url, "source_title": audit.get("source_title", ""), "source_description": audit.get("source_description", ""), "authors": audit.get("authors", ""), "publication_date": audit.get("publication_date", ""), "publication_year": audit.get("publication_year", ""), "publication_venue": publication_venue, "publisher": publisher, "doi": audit.get("doi", ""), "publication_note": audit.get("publication_note", ""), "primary_category": audit.get("primary_category", ""), "metadata_source": audit.get("metadata_source", "not-audited"), "github_repo": audit.get("github_repo", ""), "github_stars": audit.get("github_stars", ""), "github_forks": audit.get("github_forks", ""), "github_license": audit.get("github_license", ""), "github_created_at": audit.get("github_created_at", ""), "github_updated_at": audit.get("github_updated_at", ""), "arxiv_id": audit.get("arxiv_id", ""), "audited_at": audit.get("retrieved_at", ""), } ) if not rows: raise RuntimeError(f"No resource entries found in {readme_path}") return rows def write_outputs(rows: list[dict[str, str]], csv_path: Path, jsonl_path: Path, site_json_path: Path) -> None: csv_path.parent.mkdir(parents=True, exist_ok=True) with csv_path.open("w", encoding="utf-8", newline="") as handle: writer = csv.DictWriter(handle, fieldnames=FIELDS, lineterminator="\n") writer.writeheader() writer.writerows(rows) with jsonl_path.open("w", encoding="utf-8") as handle: for row in rows: handle.write(json.dumps(row, ensure_ascii=False, sort_keys=False)) handle.write("\n") site_json_path.parent.mkdir(parents=True, exist_ok=True) payload = { "count": len(rows), "resources": [{field: row[field] for field in SITE_FIELDS} for row in rows], } site_json_path.write_text( json.dumps(payload, ensure_ascii=False, separators=(",", ":")) + "\n", encoding="utf-8", ) def check_outputs(rows: list[dict[str, str]]) -> int: with TemporaryDirectory() as temp_dir: temp = Path(temp_dir) expected_csv = temp / "resources.csv" expected_jsonl = temp / "resources.jsonl" expected_site_json = temp / "resources.json" write_outputs(rows, expected_csv, expected_jsonl, expected_site_json) failures = [] for expected, actual in [ (expected_csv, CSV_PATH), (expected_jsonl, JSONL_PATH), (expected_site_json, SITE_JSON_PATH), ]: if not actual.exists(): failures.append(f"{actual.relative_to(ROOT)} is missing") continue if expected.read_text(encoding="utf-8") != actual.read_text(encoding="utf-8"): failures.append(f"{actual.relative_to(ROOT)} is stale; run scripts/export_resource_dataset.py") if failures: for failure in failures: print(failure, file=sys.stderr) return 1 return 0 def main() -> int: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--check", action="store_true", help="fail if generated dataset files are stale") args = parser.parse_args() rows = iter_rows() if args.check: return check_outputs(rows) write_outputs(rows, CSV_PATH, JSONL_PATH, SITE_JSON_PATH) print( f"Wrote {len(rows)} rows to {CSV_PATH.relative_to(ROOT)}, " f"{JSONL_PATH.relative_to(ROOT)}, and {SITE_JSON_PATH.relative_to(ROOT)}" ) return 0 if __name__ == "__main__": raise SystemExit(main())