primarysource 0.1.0__py3-none-any.whl

primarysource/draft/licence.py

@@ -0,0 +1,89 @@
+"""What an Internet-Draft's own legends say about reuse, read from its text and, when it has one, its XML.
+
+This is information for `info`, not legal advice. The sources are:
+
+- BCP 78 (RFC 5378) §3.6: contributors keep the copyright in their Internet-Drafts and grant the IETF Trust
+  non-exclusive rights; §5.4: the Trust sublicenses them for the IETF Standards Process and may sublicense more;
+- the IETF Trust's Trust Legal Provisions 5.0, §3.c: anyone may copy, publish, display and distribute a
+  Contribution "in full and without modification", or unmodified portions with attribution, and §3.d: no licence
+  to modify outside the Standards Process, and none to distribute without the required legends. §1.b and §1.c:
+  that applies to Contributions submitted after 2015-03-25; older ones stay under the policy in force then;
+- RFC 7991 Appendix A.1.1: the `ipr` values, three of which add a legend that withdraws the right to modify.
+
+So a draft is not covered by one blanket licence: the answer depends on its submission date and its legends.
+That is why this collection stores drafts on the reader's own volume and never in an image (docs/draft.md).
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+NONE = "none"
+NO_MODIFICATION = "no-modification"
+NO_DERIVATIVES = "no-derivatives"
+PRE_5378 = "pre-5378"
+
+TLP5_EFFECTIVE = (2015, 3, 25)
+
+_IPR = {
+    "trust200902": NONE,
+    "nomodificationtrust200902": NO_MODIFICATION,
+    "noderivativestrust200902": NO_DERIVATIVES,
+    "pre5378trust200902": PRE_5378,
+}
+_YEAR = re.compile(r"Copyright \(c\) (\d{4}) IETF Trust")
+_NO_DERIVATIVES = re.compile(r"may not be published except as an Internet-Draft", re.I)
+_NO_MODIFICATION = re.compile(
+    r"This document may not be modified, and derivative works of it may not be created", re.I
+)
+_PRE_5378 = re.compile(
+    r"may contain material from IETF Documents or IETF Contributions published or made publicly", re.I
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Licence:
+    """`restriction` is one of NONE, NO_MODIFICATION, NO_DERIVATIVES, PRE_5378; `year` is the copyright year of
+    the IETF Trust notice, 0 if there is none; `ipr` is the xml2rfc `ipr` attribute, or ''."""
+
+    restriction: str
+    year: int
+    ipr: str
+
+    def summary(self) -> str:
+        """One line for `info`."""
+        parts = []
+        if self.year and self.year < TLP5_EFFECTIVE[0]:
+            parts.append(
+                f"copyright {self.year}: submitted before the Trust Legal Provisions 5.0 (2015-03-25), so the "
+                "policy in force at its submission applies, not TLP 5.0 (TLP 5.0 §1.c)"
+            )
+        elif self.year:
+            parts.append(f"copyright {self.year} IETF Trust and the authors; Trust Legal Provisions 5.0 §3.c applies")
+        else:
+            parts.append("no IETF Trust copyright notice found: check the draft's own legends")
+        if self.restriction == NO_MODIFICATION:
+            parts.append("its legend forbids modification (TLP 6.c.i)")
+        elif self.restriction == NO_DERIVATIVES:
+            parts.append("its legend forbids modification and publication except as an Internet-Draft (TLP 6.c.ii)")
+        elif self.restriction == PRE_5378:
+            parts.append("its pre-5378 legend limits modification outside the IETF Standards Process (TLP 6.c.iii)")
+        return "; ".join(parts)
+
+
+def detect(text: str, xml_ipr: str = "") -> Licence:
+    """Read the legend from the text (whitespace collapsed, since the legend wraps) and the XML `ipr`. A legend in
+    the text wins over the attribute, because the text is what a reader sees."""
+    flat = " ".join(text.split())
+    restriction = NONE
+    if _NO_DERIVATIVES.search(flat):
+        restriction = NO_DERIVATIVES
+    elif _PRE_5378.search(flat):
+        restriction = PRE_5378
+    elif _NO_MODIFICATION.search(flat):
+        restriction = NO_MODIFICATION
+    if restriction == NONE:
+        restriction = _IPR.get(xml_ipr.lower(), NONE)
+    match = _YEAR.search(flat)
+    return Licence(restriction, int(match.group(1)) if match else 0, xml_ipr)

primarysource/draft/names.py

@@ -0,0 +1,64 @@
+"""What a draft's name and revision look like, and how a ref's document part is split into the two.
+
+The datatracker names a draft `draft-<words>` in lowercase letters, digits and hyphens, and a revision is two
+digits, `00` to `99`, appended with a hyphen: `draft-ietf-sidrops-8210bis-17`. A trailing `-NN` of exactly two
+digits is read as the revision, which is how the datatracker itself reads it; a draft whose own name ends in two
+digits therefore has to be written with its revision (`draft-foo-bar-12-00`) to be unambiguous.
+
+Every name that reaches a URL or a path passes `parse_name` or `split_doc` first, so none of `/`, `..`, `%`, a
+newline or an uppercase letter gets any further.
+"""
+
+from __future__ import annotations
+
+import re
+
+from primarysource.errors import LibError
+from primarysource.refs import RefGrammar
+
+MAX_NAME = 120
+_WORDS = r"draft-[a-z0-9]+(?:-[a-z0-9]+)*"
+_NAME = re.compile(_WORDS)
+_REVISION = re.compile(r"[0-9]{2}")
+_DOC = re.compile(r"(?P<name>draft-[a-z0-9]+(?:-[a-z0-9]+)*?)(?:-(?P<rev>[0-9]{2}))?")
+
+DOC_PATTERN = r"draft-[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*"
+"""For the ref grammar: the name, with or without its revision. Case is folded by `split_doc`."""
+
+SECTION_PATTERN = r"[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*"
+"""A section id: `5.1`, `A.2` (an appendix), or a title slug for an unnumbered section (`abstract`)."""
+
+GRAMMAR = RefGrammar(DOC_PATTERN, SECTION_PATTERN)
+
+_HINT = "a draft is named draft-<words>, optionally followed by -NN, e.g. draft-ietf-sidrops-8210bis-17"
+
+
+def parse_name(text: str) -> str:
+    """A draft name without a revision, or a LibError. Case is folded; nothing else is repaired."""
+    name = text.strip().lower()
+    if len(name) > MAX_NAME or not _NAME.fullmatch(name):
+        raise LibError(f"not a draft name: {text[:60]!r}", _HINT)
+    return name
+
+
+def valid_revision(text: str) -> str:
+    """A two-digit revision, or a LibError."""
+    if not _REVISION.fullmatch(text):
+        raise LibError(f"not a revision: {text[:20]!r}", "a revision is two digits, 00 to 99")
+    return text
+
+
+def split_doc(text: str) -> tuple[str, str | None]:
+    """`draft-x-y-17` -> (`draft-x-y`, `17`); `draft-x-y` -> (`draft-x-y`, None)."""
+    doc = text.strip().lower()
+    if len(doc) > MAX_NAME + 3:
+        raise LibError(f"not a draft name: {text[:60]!r}", _HINT)
+    match = _DOC.fullmatch(doc)
+    if match is None:
+        raise LibError(f"not a draft name: {text[:60]!r}", _HINT)
+    return parse_name(match["name"]), match["rev"]
+
+
+def with_revision(name: str, rev: str) -> str:
+    """`draft-x-y` and `17` -> `draft-x-y-17`."""
+    return f"{parse_name(name)}-{valid_revision(rev)}"

primarysource/draft/net.py

@@ -0,0 +1,133 @@
+"""The only code in this collection that touches the network, behind an injectable transport.
+
+A `Transport` is a function from a URL to a `Response`; tests pass their own and never open a socket. The real
+one (`urllib_transport`) is held to three rules that a draft's bytes being public does not relax:
+
+- only `https` and only the two hosts the IETF serves drafts and metadata from, redirects included, so a
+  redirect cannot send the importer somewhere the person did not name;
+- a hard ceiling on the body, read in chunks, so a hostile or broken server cannot fill memory;
+- a fixed User-Agent that names this package and carries nothing about the person.
+
+`Fetcher` adds the courtesy the IETF asks of automated clients: one request per second, spaced from the end of
+the previous request, a bounded retry on 429 and 5xx that honours `Retry-After`, and nothing else.
+"""
+
+from __future__ import annotations
+
+import time
+import urllib.error
+import urllib.request
+from collections.abc import Callable
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+from primarysource import __version__
+from primarysource.errors import LibError
+
+DATATRACKER = "datatracker.ietf.org"
+ARCHIVE = "www.ietf.org"
+ALLOWED_HOSTS = (DATATRACKER, ARCHIVE)
+USER_AGENT = f"primarysource-draft/{__version__}"
+MAX_BODY = 8_000_000
+INTERVAL = 1.0
+RETRIES = 2
+MAX_RETRY_WAIT = 30.0
+
+
+@dataclass(frozen=True, slots=True)
+class Response:
+    """What a transport returns: the HTTP status, the body (at most `MAX_BODY` bytes), the content type and the
+    `Retry-After` header if the server sent one. A transport returns 4xx and 5xx; it raises only when no HTTP
+    answer came back at all."""
+
+    status: int
+    body: bytes
+    content_type: str = ""
+    retry_after: float | None = None
+
+
+Transport = Callable[[str], Response]
+
+
+def check_url(url: str) -> None:
+    """Refuse a URL that is not https on an allowed host. Used before a request and again on every redirect."""
+    parts = urlsplit(url)
+    if parts.scheme != "https" or parts.hostname not in ALLOWED_HOSTS or parts.username or parts.password:
+        raise LibError(f"refusing to fetch {url[:100]!r}: only https://{DATATRACKER} and https://{ARCHIVE}", "")
+
+
+class _Redirects(urllib.request.HTTPRedirectHandler):
+    def redirect_request(
+        self, req: urllib.request.Request, fp: object, code: int, msg: str, headers: object, newurl: str
+    ) -> urllib.request.Request | None:
+        check_url(newurl)
+        return super().redirect_request(req, fp, code, msg, headers, newurl)  # type: ignore[arg-type]
+
+
+def _retry_after(value: str | None) -> float | None:
+    try:
+        return float(value) if value is not None else None
+    except ValueError:
+        return None  # an HTTP-date form is ignored; the fixed back-off applies
+
+
+def urllib_transport(url: str, timeout: float = 30.0) -> Response:
+    """GET `url` with the standard library, under the rules in the module docstring."""
+    check_url(url)
+    opener = urllib.request.build_opener(_Redirects)
+    request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept-Encoding": "identity"})  # noqa: S310
+    try:
+        with opener.open(request, timeout=timeout) as reply:
+            body = reply.read(MAX_BODY + 1)
+            if len(body) > MAX_BODY:
+                raise LibError(f"{url} is larger than {MAX_BODY:,} bytes; refusing it", "")
+            return Response(reply.status, body, reply.headers.get("Content-Type", ""))
+    except urllib.error.HTTPError as exc:
+        return Response(
+            exc.code, b"", exc.headers.get("Content-Type", ""), _retry_after(exc.headers.get("Retry-After"))
+        )
+    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        raise LibError(f"could not reach {urlsplit(url).hostname}: {exc}", "check the network and try again") from exc
+
+
+class Fetcher:
+    """Rate-limited, retrying GET over a transport. `clock` and `sleep` are injectable so tests take no time."""
+
+    def __init__(
+        self,
+        transport: Transport = urllib_transport,
+        interval: float = INTERVAL,
+        clock: Callable[[], float] = time.monotonic,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        self._transport = transport
+        self._interval = interval
+        self._clock = clock
+        self._sleep = sleep
+        self._last: float | None = None
+        self.requests = 0
+
+    def _wait(self) -> None:
+        if self._last is not None:
+            remaining = self._interval - (self._clock() - self._last)
+            if remaining > 0:
+                self._sleep(remaining)
+
+    def get(self, url: str) -> Response:
+        """The response for `url`, which may be a 404 (the caller decides what that means). A 429 or 5xx is
+        retried `RETRIES` times, then raised as a LibError that says to try later."""
+        check_url(url)
+        attempt = 0
+        while True:
+            self._wait()
+            try:
+                reply = self._transport(url)
+            finally:
+                self._last = self._clock()
+                self.requests += 1
+            if reply.status != 429 and reply.status < 500:
+                return reply
+            if attempt >= RETRIES:
+                raise LibError(f"{urlsplit(url).hostname} answered {reply.status} for {url[:100]}", "try again later")
+            attempt += 1
+            self._sleep(min(reply.retry_after if reply.retry_after is not None else 5.0 * attempt, MAX_RETRY_WAIT))

primarysource/draft/segment.py

@@ -0,0 +1,192 @@
+"""Draft text -> sections and paragraph blocks, by the `rfc` collection's `.txt` segmenter.
+
+A draft's `.txt` is the same xml2rfc rendering as an RFC's, so `primarysource.rfc.index.txtseg` (table of
+contents as the answer key, headings found in order, paragraphs re-joined across page breaks) reads it
+unchanged; the one thing a draft adds is its own page furniture, which that segmenter already skips by its
+`[Page N]` footer. The author's `.xml` is not segmented: it is the *submitted* source, not the prepared one, so
+it has no `pn` ids and no section numbers, which is what `rfc.index.rfcxml` needs. See `docs/draft.md`.
+
+What is added here:
+
+- the text is normalised first (CRLF and lone CR to LF, form feeds and the other `str.splitlines` separators
+  removed) so line N of the segmentation is line N of the file, and refs like `draft-x-y-03:100-120` mean what
+  they say;
+- hostile text is refused before the segmenter sees it (NUL, over-long lines, over-size files), because its
+  regular expressions are written for well-formed RFC text;
+- section ids are the ones a ref can carry: `5.1`, `A.2` for an appendix, a title slug for an unnumbered
+  section (`abstract`, `security-considerations`), made unique with `-2`, `-3`.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from primarysource.errors import LibError
+from primarysource.rfc.index import txtseg
+
+PARSER_VERSION = "2"
+MAX_TEXT_BYTES = 8_000_000
+MAX_LINE = 2_000
+MAX_LINES = 60_000
+
+_SEPARATORS = str.maketrans({c: " " for c in "\x0b\x1c\x1d\x1e\x85

"} | {"\f": None})
+_SLUG = re.compile(r"[^a-z0-9]+")
+# The running header of a draft's pages: "Internet-Draft    Short Title    November 2026". The rfc segmenter skips
+# the same line in an RFC ("RFC 9000    QUIC    May 2021") and re-joins the paragraph the page break cut, so the
+# header is rewritten to that spelling, column for column, rather than blanked (which would split the paragraph).
+_PAGE_HEADER = re.compile(r"^Internet-Draft( {2,}.*\S {2,}\S+ \d{4}\s*)$")
+
+
+@dataclass(frozen=True, slots=True)
+class Block:
+    """One paragraph, list, figure or table of a section, with its 1-based line range in the normalised text."""
+
+    text: str
+    kind: str
+    start: int
+    end: int
+
+
+@dataclass(frozen=True, slots=True)
+class DSection:
+    """`id` is what a ref's `§` carries; `num` is the number the draft prints (`5.1`, `Appendix A`, or '')."""
+
+    id: str
+    num: str
+    title: str
+    depth: int
+    head_line: int
+    end_line: int
+    blocks: tuple[Block, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class Segmented:
+    sections: tuple[DSection, ...]
+    lines: int
+    method: str
+    notes: tuple[str, ...]
+
+    def section(self, section_id: str) -> DSection | None:
+        for candidate in self.sections:
+            if candidate.id == section_id:
+                return candidate
+        return None
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "parser": PARSER_VERSION,
+                "lines": self.lines,
+                "method": self.method,
+                "notes": list(self.notes),
+                "sections": [
+                    {
+                        "id": s.id,
+                        "num": s.num,
+                        "title": s.title,
+                        "depth": s.depth,
+                        "head": s.head_line,
+                        "end": s.end_line,
+                        "blocks": [[b.text, b.kind, b.start, b.end] for b in s.blocks],
+                    }
+                    for s in self.sections
+                ],
+            },
+            ensure_ascii=False,
+        )
+
+    @staticmethod
+    def from_json(text: str) -> Segmented | None:
+        """The cached segmentation, or None when it is damaged or was made by another parser version (the caller
+        then segments the stored text again)."""
+        try:
+            raw: dict[str, Any] = json.loads(text)
+            if raw["parser"] != PARSER_VERSION:
+                return None
+            sections = tuple(
+                DSection(
+                    str(s["id"]),
+                    str(s["num"]),
+                    str(s["title"]),
+                    int(s["depth"]),
+                    int(s["head"]),
+                    int(s["end"]),
+                    tuple(Block(str(b[0]), str(b[1]), int(b[2]), int(b[3])) for b in s["blocks"]),
+                )
+                for s in raw["sections"]
+            )
+            return Segmented(sections, int(raw["lines"]), str(raw["method"]), tuple(str(n) for n in raw["notes"]))
+        except (ValueError, KeyError, TypeError, IndexError):
+            return None
+
+
+def decode(data: bytes) -> tuple[str, str]:
+    """Bytes of a draft's `.txt` -> (text, encoding). UTF-8 if it is, else Latin-1, which the oldest drafts are;
+    a NUL byte means this is not a text draft at all."""
+    if len(data) > MAX_TEXT_BYTES:
+        raise LibError(f"a draft text of {len(data):,} bytes is over the {MAX_TEXT_BYTES:,} byte limit", "")
+    if b"\x00" in data:
+        raise LibError("the file holds NUL bytes: this is not a text draft", "")
+    try:
+        return data.decode("utf-8"), "utf-8"
+    except UnicodeDecodeError:
+        return data.decode("latin-1"), "latin-1"
+
+
+def normalise(text: str) -> list[str]:
+    """Lines of `text` such that line N is the Nth newline-separated line of the file, with the BOM, form feeds and
+    odd separators gone. Raises a LibError for a line or a file the segmenter should not be handed."""
+    flat = text.lstrip("").replace("\r\n", "\n").replace("\r", "\n").translate(_SEPARATORS)
+    lines = flat.split("\n")
+    if len(lines) > MAX_LINES:
+        raise LibError(f"{len(lines):,} lines is over the {MAX_LINES:,} line limit for a draft", "")
+    longest = max((len(line) for line in lines), default=0)
+    if longest > MAX_LINE:
+        raise LibError(
+            f"a line of {longest:,} characters is over the {MAX_LINE:,} limit: this is not a text draft", ""
+        )
+    return [_PAGE_HEADER.sub(lambda m: "RFC 0" + " " * 9 + m.group(1), line) for line in lines]
+
+
+def section_id(num: str, title: str, used: set[str]) -> str:
+    """A ref-safe, unique id for a section."""
+    if num.startswith("Appendix "):
+        base = num.split(" ", 1)[1]
+    elif num:
+        base = num
+    else:
+        base = _SLUG.sub("-", title.lower()).strip("-")[:60] or "section"
+    found, n = base, 2
+    while found in used:
+        found, n = f"{base}-{n}", n + 1
+    used.add(found)
+    return found
+
+
+def segment(text: str) -> Segmented:
+    """Sections and blocks of a draft's text. Never returns nothing: a draft with no headings is one section."""
+    lines = normalise(text)
+    parsed, quality = txtseg.segment("\n".join(lines), "draft")
+    shift = 0
+    if any("no headings" in note for note in quality.notes):
+        # the rfc segmenter treats line 1 as the heading of its single "Entire document" section and drops it;
+        # one blank line in front gives that role to nothing, and every line number is then one too high
+        parsed, quality = txtseg.segment("\n" + "\n".join(lines), "draft")
+        shift = 1
+    used: set[str] = set()
+    sections: list[DSection] = []
+    for s in parsed.sections:
+        blocks = tuple(
+            Block(b.text, b.kind, b.start_line - shift, b.end_line - shift) for b in s.blocks if b.text.strip()
+        )
+        sections.append(
+            DSection(
+                section_id(s.sec_num, s.title, used), s.sec_num, s.title, s.depth,
+                max(1, s.head_line - shift), max(1, s.end_line - shift), blocks,
+            )
+        )  # fmt: skip
+    return Segmented(tuple(sections), len(lines), quality.method, tuple(quality.notes))

primarysource/draft/server.py

@@ -0,0 +1,91 @@
+"""The MCP server for the draft collection: `primarysource mcp --collection draft`.
+
+Imported only when served, so `mcp` (the `[mcp]` extra) is needed only then. Tools carry the `draft_` prefix,
+answer in text with the fixed footer, and turn a `LibError` into an MCP tool error (`isError`) whose text names
+the remedy. Every tool reads local files only: none writes, none fetches. Drafts arrive by
+`primarysource draft import`, which is a command a person runs, not a tool an agent calls.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from primarysource import __version__
+from primarysource.draft import views
+from primarysource.draft.store import Store
+from primarysource.scaffold import add_tools
+
+READ_ONLY = ToolAnnotations(read_only_hint=True, idempotent_hint=True, destructive_hint=False, open_world_hint=False)
+
+INSTRUCTIONS = (
+    "IETF Internet-Drafts from the user's own imported copies: documents that exist only as drafts (RTR version 2 "
+    "and the ASPA PDU, ASPA verification, LibrePGP, the TURN REST API). A draft is not a standard: it has "
+    "revisions, expires six months after its last one, and is replaced or becomes an RFC. Every result names the "
+    "revision it read and, when the draft is dead (expired, replaced, withdrawn, published as an RFC) or the "
+    "revision is not the latest, says so in a banner line and in the warning: footer. Never quote or cite a "
+    "draft without reading that. Cite only as 'Work in Progress' with the cite: line. Loop: draft_list -> "
+    "draft_info('<name>') -> draft_search('<words>') or draft_outline('<name>') -> draft_read('<ref>') -> "
+    "draft_cite('<ref>'). Refs: 'draft-ietf-sidrops-8210bis-17§5.1¶2'; without the -17 the latest stored revision "
+    "is read and the result says so. If a draft is not stored, the error says which command imports it."
+)
+
+
+def _library() -> Store:
+    return Store()
+
+
+def draft_read(ref: str, max_tokens: int = 2000) -> str:
+    """Read a stored Internet-Draft by ref, cut at paragraph boundaries within max_tokens. A 'next: <ref>' footer
+    line is the ref that reads the next page: pass it back as ref. Read the banner and warning: lines first: they
+    say if the draft is expired, replaced, withdrawn or an RFC now, and if the revision is not the latest.
+
+    ref: 'draft-ietf-sidrops-8210bis-17' (abstract and outline) | '...-17§5.1' (a section) | '...-17§5.1¶2' (from
+      its 2nd paragraph) | '...-17:100-120' (lines of the text) | without '-17' the latest stored revision, said so.
+      Sections are numbered as the draft prints them; 'A.1' is Appendix A.1; unnumbered ones are 'abstract',
+      'security-considerations'."""
+    return views.read(_library(), ref, max_tokens=max_tokens)
+
+
+def draft_outline(name: str) -> str:
+    """List a stored draft's sections, each as the ref that reads it with its paragraph count. name:
+    'draft-ietf-sidrops-8210bis' or '...-17'."""
+    return views.outline(_library(), name)
+
+
+def draft_search(query: str, name: str | None = None, limit: int = 10) -> str:
+    """Search the sections of the stored drafts (each draft's latest stored revision) by words, best first. One
+    line per hit: '<ref>  <section>: <snippet>', with [expired], [replaced] and so on after hits in a draft that
+    is not alive. name: restrict to one draft or one revision. limit: 1 to 50."""
+    return views.search(_library(), query, limit=limit, name=name)
+
+
+def draft_cite(ref: str) -> str:
+    """The citation for a draft ref: authors, title, 'Work in Progress, Internet-Draft', name-revision, date, URL
+    and section, with a span: hash of the cited text. Drafts may be cited only as work in progress (RFC 2026
+    §2.2); the warning: line says if this one is dead."""
+    return views.cite(_library(), ref)
+
+
+def draft_info(name: str) -> str:
+    """Standing of a draft: datatracker state, latest revision, expiry, what replaced it, whether it became an
+    RFC, revisions stored, licence legend and pins. Call this before relying on a draft."""
+    return views.info(_library(), name)
+
+
+def draft_list() -> str:
+    """List the tracked and stored drafts with stored revisions, latest known revision, state and replacement."""
+    return views.list_tracked(_library())
+
+
+def _build() -> Any:
+    tools: list[Callable[..., str]] = [draft_read, draft_outline, draft_search, draft_cite, draft_info, draft_list]
+    built = MCPServer("primarysource-draft", version=__version__, instructions=INSTRUCTIONS)
+    add_tools(built, tools, annotations=READ_ONLY)
+    return built
+
+
+server = _build()