metatron-cli 0.2.1__py3-none-any.whl

metatron/normalize.py

@@ -0,0 +1,141 @@
+"""URL and title normalization for the first layers of dedup.
+
+Cheap pure functions. Catches the easy duplicates (same article, different
+tracking params; same article syndicated with different ?utm_*; "BREAKING:"
+prefixed reprints) without any LLM calls.
+"""
+
+from __future__ import annotations
+
+import re
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+
+_TRACKING_PARAM_PREFIXES = (
+    "utm_",
+    "ga_",
+    "mc_",
+    "_hs",
+    "hsa_",
+    "matomo_",
+    "pk_",
+    "fb_",
+)
+_TRACKING_PARAM_EXACT = {
+    "fbclid",
+    "gclid",
+    "msclkid",
+    "dclid",
+    "yclid",
+    "twclid",
+    "igshid",
+    "mkt_tok",
+    "ref",
+    "ref_src",
+    "ref_url",
+    "source",
+    "src",
+    "amp",
+    "share",
+    "from",
+    "feed",
+}
+
+
+def canonicalize_url(url: str) -> str:
+    """Return a stable canonical form of an article URL.
+
+    Operations:
+      - lowercase the scheme and host
+      - drop www. prefix from host
+      - drop default port for http/https
+      - drop fragment
+      - drop tracking query params (utm_*, fbclid, etc.)
+      - sort remaining query params for stability
+      - strip trailing slash on non-empty paths
+    """
+    if not url:
+        return ""
+    parts = urlsplit(url.strip())
+
+    scheme = (parts.scheme or "https").lower()
+    host = (parts.hostname or "").lower()
+    if host.startswith("www."):
+        host = host[4:]
+    netloc = host
+    if parts.port and not (
+        (scheme == "http" and parts.port == 80)
+        or (scheme == "https" and parts.port == 443)
+    ):
+        netloc = f"{host}:{parts.port}"
+
+    path = parts.path
+    if len(path) > 1 and path.endswith("/"):
+        path = path[:-1]
+
+    kept_params = []
+    for key, value in parse_qsl(parts.query, keep_blank_values=False):
+        k = key.lower()
+        if k in _TRACKING_PARAM_EXACT:
+            continue
+        if any(k.startswith(p) for p in _TRACKING_PARAM_PREFIXES):
+            continue
+        kept_params.append((key, value))
+    kept_params.sort()
+    query = urlencode(kept_params)
+
+    return urlunsplit((scheme, netloc, path, query, ""))
+
+
+_TITLE_PUNCT_RE = re.compile(r"[^\w\s]")
+_TITLE_WS_RE = re.compile(r"\s+")
+_TITLE_PREFIX_RE = re.compile(
+    r"^\s*(breaking|exclusive|update(d)?|analysis|opinion|video|live|watch)"
+    r"\s*[:\-—–]\s*",
+    re.IGNORECASE,
+)
+
+
+def normalize_title(title: str) -> str:
+    """Return a normalized title suitable for fingerprint comparison.
+
+    Lowercase, drop punctuation, collapse whitespace, strip common newsroom
+    prefixes ("BREAKING: ", "UPDATE -", etc.).
+    """
+    if not title:
+        return ""
+    s = title.strip()
+    # Repeatedly strip prefixes (some titles have stacked "BREAKING: UPDATE: ...")
+    while True:
+        m = _TITLE_PREFIX_RE.match(s)
+        if not m:
+            break
+        s = s[m.end() :]
+    s = s.lower()
+    s = _TITLE_PUNCT_RE.sub(" ", s)
+    s = _TITLE_WS_RE.sub(" ", s).strip()
+    return s
+
+
+_TOKEN_RE = re.compile(r"\w+")
+_STOPWORDS = {
+    "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+    "to", "of", "in", "on", "at", "for", "by", "from", "with", "as",
+    "and", "or", "but", "if", "than", "then", "that", "this", "these",
+    "those", "it", "its", "into", "over", "after", "before", "about",
+    "up", "down", "out", "off", "via", "vs", "v",
+}
+
+
+def tokenize(text: str) -> set[str]:
+    """Return a set of meaningful tokens for cheap overlap comparison."""
+    if not text:
+        return set()
+    return {t for t in (m.group(0).lower() for m in _TOKEN_RE.finditer(text)) if t not in _STOPWORDS and len(t) > 2}
+
+
+def jaccard(a: set[str], b: set[str]) -> float:
+    """Jaccard similarity between two token sets. 0.0 if either is empty."""
+    if not a or not b:
+        return 0.0
+    return len(a & b) / len(a | b)

metatron/poller.py

@@ -0,0 +1,325 @@
+"""Feed poller — fetch all feeds, dedup in one batched LLM call, store.
+
+Per refresh / poll-tick:
+
+  1. Mark every due feed "polled" (claims it against concurrent runs).
+  2. Fetch and parse each feed.
+  3. Run the cheap dedup layers (URL + normalized title) per item; either
+     drop it as an exact duplicate or attach it to an existing cluster.
+  4. For the items that survive, build one BatchPlan and call the LLM
+     once. Apply the returned groupings.
+  5. Insert candidates as either: a new article, a join to an existing
+     cluster, or a new cluster formed across candidates.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+from metatron.db import Database
+from metatron.dedup import DedupConfig, build_batch_plan, cheap_decide, run_batch
+from metatron.fetcher import FeedFetchError, parse_feed
+from metatron.llm import BatchJudge
+from metatron.normalize import canonicalize_url
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PollStats:
+    polled: int = 0
+    new_articles: int = 0
+    duplicates: int = 0
+    cluster_joins: int = 0
+    feed_errors: int = 0
+
+    def as_dict(self) -> dict[str, int]:
+        return {
+            "polled": self.polled,
+            "new_articles": self.new_articles,
+            "duplicates": self.duplicates,
+            "cluster_joins": self.cluster_joins,
+            "feed_errors": self.feed_errors,
+        }
+
+
+class Poller:
+    """Async background poller that runs alongside the FastAPI app."""
+
+    def __init__(
+        self,
+        *,
+        db: Database,
+        judge: BatchJudge,
+        tick_seconds: int = 60,
+        feed_timeout_seconds: int = 30,
+        dedup_config: DedupConfig | None = None,
+    ) -> None:
+        self.db = db
+        self.judge = judge
+        self.tick_seconds = tick_seconds
+        self.feed_timeout_seconds = feed_timeout_seconds
+        self.dedup_config = dedup_config or DedupConfig()
+        self._task: asyncio.Task[None] | None = None
+        self._stop_event: asyncio.Event | None = None
+
+    def start(self) -> None:
+        if self._task is not None and not self._task.done():
+            return
+        loop = asyncio.get_event_loop()
+        self._stop_event = asyncio.Event()
+        self._task = loop.create_task(self._run(), name="metatron-poller")
+        logger.info("Background poller started")
+
+    async def stop(self) -> None:
+        if self._stop_event is not None:
+            self._stop_event.set()
+        if self._task is not None:
+            try:
+                await asyncio.wait_for(self._task, timeout=10.0)
+            except asyncio.TimeoutError:
+                self._task.cancel()
+        logger.info("Background poller stopped")
+
+    async def _run(self) -> None:
+        assert self._stop_event is not None
+        while not self._stop_event.is_set():
+            try:
+                await asyncio.get_running_loop().run_in_executor(None, self._tick)
+            except Exception as e:  # noqa: BLE001 - keep loop alive
+                logger.exception("Poller tick failed: %s", e)
+            try:
+                await asyncio.wait_for(self._stop_event.wait(), timeout=self.tick_seconds)
+            except asyncio.TimeoutError:
+                pass
+
+    def _tick(self) -> None:
+        due = self.db.list_due_feeds()
+        if not due:
+            return
+        by_project: dict[str, list[dict[str, Any]]] = {}
+        for feed in due:
+            by_project.setdefault(feed["project_id"], []).append(feed)
+        for project_id, feeds in by_project.items():
+            poll_feeds(
+                project_id,
+                feeds,
+                self.db,
+                self.judge,
+                self.dedup_config,
+                self.feed_timeout_seconds,
+            )
+
+
+# ── core poll routine ────────────────────────────────────────────────────
+
+
+def poll_feeds(
+    project_id: str,
+    feeds: list[dict[str, Any]],
+    db: Database,
+    judge: BatchJudge,
+    dedup_config: DedupConfig,
+    feed_timeout_seconds: int,
+) -> PollStats:
+    """Fetch and dedup a batch of feeds for one project, with one LLM call."""
+    stats = PollStats()
+    if not feeds:
+        return stats
+
+    # Claim everything immediately so concurrent polls don't pile on.
+    for feed in feeds:
+        db.mark_feed_polled(feed["id"], error=None)
+
+    # --- Phase 1: fetch all feeds, gather raw candidates ---
+    raw: list[tuple[dict[str, Any], dict[str, Any]]] = []  # (feed_row, parsed_item)
+    for feed in feeds:
+        stats.polled += 1
+        try:
+            items = parse_feed(
+                feed["url"],
+                source_name=feed.get("name") or None,
+                timeout=feed_timeout_seconds,
+            )
+        except FeedFetchError as e:
+            logger.warning("Feed %s failed: %s", feed["url"], e)
+            db.mark_feed_polled(feed["id"], error=str(e)[:500])
+            stats.feed_errors += 1
+            continue
+        for item in items:
+            raw.append((feed, item))
+
+    if not raw:
+        return stats
+
+    # --- Phase 2: cheap layers + collect survivors for LLM batching ---
+    history = db.recent_articles_for_dedup(project_id, days=7)
+    seen_canonicals: set[str] = set()
+
+    candidates: list[dict[str, Any]] = []
+    # Candidates joining clusters via cheap layers — keyed by the candidate
+    # dict's id() to avoid relying on yet-to-be-built _ref_id.
+    cheap_links: dict[int, tuple[str | None, str | None, str | None]] = {}
+    # (cluster_id, history_article_id, peer_candidate_id_marker)
+
+    for feed, item in raw:
+        canonical = canonicalize_url(item.source_url)
+        if not canonical:
+            continue
+        if canonical in seen_canonicals:
+            stats.duplicates += 1
+            continue
+        if db.get_article_by_canonical_url(project_id, canonical):
+            stats.duplicates += 1
+            seen_canonicals.add(canonical)
+            continue
+
+        candidate = {
+            "project_id": project_id,
+            "canonical_url": canonical,
+            "source_url": item.source_url,
+            "source": item.source,
+            "title": item.title,
+            "summary": item.summary,
+            "body": item.body,
+            "published": item.published.isoformat() if item.published else None,
+        }
+
+        # Cheap-decide against history plus already-queued candidates (so a
+        # near-identical second-feed copy of the same headline within the
+        # same poll joins the first one's cluster without needing the LLM).
+        within_batch_history = history + [
+            {"id": f"_cand_{id(c)}", **c} for c in candidates
+        ]
+        decision = cheap_decide(candidate, within_batch_history)
+
+        if decision.status == "duplicate":
+            stats.duplicates += 1
+            seen_canonicals.add(canonical)
+            continue
+
+        seen_canonicals.add(canonical)
+
+        if decision.status == "cluster":
+            history_id = decision.canonical_article_id
+            if history_id and history_id.startswith("_cand_"):
+                # Matched another in-batch candidate; resolve to a real
+                # cluster after that candidate is inserted.
+                cheap_links[id(candidate)] = (None, None, history_id)
+            else:
+                cheap_links[id(candidate)] = (
+                    decision.cluster_id,
+                    decision.canonical_article_id,
+                    None,
+                )
+
+        candidates.append(candidate)
+
+    if not candidates:
+        return stats
+
+    # --- Phase 3: one LLM call across ALL surviving candidates + their peers ---
+    plan = build_batch_plan(candidates, history, config=dedup_config)
+    matches = run_batch(plan, judge) if judge.enabled else {}
+
+    # Map ref_id → candidate dict for easy lookup
+    by_ref = {c["_ref_id"]: c for c in candidates}
+    history_ref_to_id = {row["id"]: row for row in history}
+
+    # --- Phase 4: write articles, respecting both cheap and LLM clusters ---
+    # Track per-candidate cluster assignment by id(candidate). After insertion,
+    # also map the in-batch marker "_cand_<id>" to the real article id so
+    # later candidates with cheap_links pointing at it can resolve.
+    candidate_to_inserted: dict[int, dict[str, Any]] = {}
+
+    for cand in candidates:
+        ref = cand.pop("_ref_id", None)
+        cluster_id_to_use: str | None = None
+
+        # (a) cheap layer linkage: either existing history or another candidate
+        cheap = cheap_links.get(id(cand))
+        if cheap is not None:
+            existing_cluster, existing_article, peer_marker = cheap
+            if peer_marker is not None:
+                # peer_marker = "_cand_<id(peer_cand)>"
+                peer_id = int(peer_marker.removeprefix("_cand_"))
+                peer_inserted = candidate_to_inserted.get(peer_id)
+                if peer_inserted is not None:
+                    cluster_id_to_use = peer_inserted.get(
+                        "cluster_id"
+                    ) or _ensure_cluster(db, project_id, peer_inserted["id"])
+                    # Backfill the peer's cluster_id so future siblings see it.
+                    peer_inserted["cluster_id"] = cluster_id_to_use
+            elif existing_cluster:
+                cluster_id_to_use = existing_cluster
+            elif existing_article:
+                cluster_id_to_use = _ensure_cluster(db, project_id, existing_article)
+
+        # (b) LLM peers — existing history or another candidate
+        if cluster_id_to_use is None and ref is not None:
+            peers = matches.get(ref, [])
+            for peer_ref in peers:
+                if peer_ref in history_ref_to_id:
+                    peer = history_ref_to_id[peer_ref]
+                    cluster_id_to_use = peer.get("cluster_id") or _ensure_cluster(
+                        db, project_id, peer["id"]
+                    )
+                    break
+            if cluster_id_to_use is None:
+                for peer_ref in peers:
+                    if peer_ref in by_ref and by_ref[peer_ref].get("cluster_id"):
+                        cluster_id_to_use = by_ref[peer_ref]["cluster_id"]
+                        break
+
+        if cluster_id_to_use:
+            cand["cluster_id"] = cluster_id_to_use
+
+        inserted = db.insert_article(cand)
+        if inserted is None:
+            stats.duplicates += 1
+            continue
+
+        # If LLM peers exist but pointed at not-yet-inserted candidates,
+        # open a fresh cluster around this article so peers can attach.
+        if cluster_id_to_use is None and ref is not None and matches.get(ref):
+            new_cluster_id = db.create_cluster(project_id, inserted["id"])
+            db.attach_to_cluster(inserted["id"], new_cluster_id)
+            inserted["cluster_id"] = new_cluster_id
+            cand["cluster_id"] = new_cluster_id
+
+        candidate_to_inserted[id(cand)] = inserted
+
+        if cluster_id_to_use:
+            stats.cluster_joins += 1
+        else:
+            stats.new_articles += 1
+
+    return stats
+
+
+def refresh_project_now(
+    project_id: str,
+    db: Database,
+    judge: BatchJudge,
+    dedup_config: DedupConfig,
+    feed_timeout_seconds: int,
+) -> dict[str, int]:
+    """Synchronously poll every enabled feed in a project — single LLM call."""
+    feeds = [f for f in db.list_feeds(project_id) if f.get("enabled")]
+    stats = poll_feeds(project_id, feeds, db, judge, dedup_config, feed_timeout_seconds)
+    return stats.as_dict()
+
+
+def _ensure_cluster(
+    db: Database, project_id: str, canonical_article_id: str
+) -> str:
+    """Find or create the cluster for ``canonical_article_id``."""
+    article = db.get_article(canonical_article_id)
+    if article and article.get("cluster_id"):
+        return article["cluster_id"]
+    cluster_id = db.create_cluster(project_id, canonical_article_id)
+    db.attach_to_cluster(canonical_article_id, cluster_id)
+    return cluster_id

metatron_cli-0.2.1.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: metatron-cli
+Version: 0.2.1
+Summary: Multi-project web feed manager with cross-outlet deduplication
+Author-email: Matt Weber <matt.weber@beefree.io>
+License: MIT
+Project-URL: Homepage, https://github.com/mattweberio/metatron
+Project-URL: Repository, https://github.com/mattweberio/metatron
+Project-URL: Issues, https://github.com/mattweberio/metatron/issues
+Keywords: rss,feeds,deduplication,news,aggregator,web,ingestion
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: feedparser>=6.0
+Requires-Dist: requests>=2.31
+Requires-Dist: trafilatura>=1.12
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: test
+Requires-Dist: pytest>=9.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Dynamic: license-file
+
+# Metatron
+
+Multi-project web feed manager with cross-outlet deduplication.
+
+You point Metatron at sources, organized by project. It polls them, dedups
+the articles (URL canonicalization → normalized title → token overlap →
+LLM tiebreaker), and serves you the unique articles via a small HTTP API.
+RSS is the source it speaks today; the architecture is medium-agnostic and
+grows to other web sources over time.
+
+It does this one thing. It doesn't curate, it doesn't summarize, it doesn't
+have opinions about what's interesting. That's for whatever calls it.
+
+## Install
+
+The CLI is `metatron`. The published package is `metatron-cli` (the bare
+`metatron` name was already taken on PyPI):
+
+```bash
+pipx install metatron-cli                                   # from PyPI
+pipx install git+https://github.com/mattweberio/metatron    # from GitHub (latest main)
+```
+
+## Configure
+
+```bash
+metatron config init       # writes ~/.config/metatron/config.toml
+metatron config show       # prints the resolved config
+```
+
+Edit `~/.config/metatron/config.toml`. The LLM tiebreaker — needed to catch
+"same story, different outlet" duplicates — requires an Anthropic API key:
+
+```toml
+[llm]
+api_key = "sk-ant-..."
+model = "claude-sonnet-4-6"
+
+[api]
+api_token = "your-bearer-token"
+```
+
+Without an LLM key, dedup falls back to URL + normalized-title matching only.
+Cross-outlet duplicates from different sources will leak through.
+
+## Run
+
+```bash
+metatron serve             # HTTP API on 127.0.0.1:8765
+```
+
+## Use
+
+Bearer-token auth on everything except `/health`.
+
+```bash
+TOKEN="your-bearer-token"
+BASE="http://127.0.0.1:8765"
+
+# Create a project
+curl -s -X POST "$BASE/projects" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "ai-news"}'
+
+# Add feeds
+PROJECT_ID=...
+curl -s -X POST "$BASE/projects/$PROJECT_ID/feeds" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://hnrss.org/frontpage"}'
+
+# List deduplicated articles
+curl -s -H "Authorization: Bearer $TOKEN" \
+  "$BASE/projects/$PROJECT_ID/articles?limit=20"
+
+# Force a synchronous refresh
+curl -s -X POST -H "Authorization: Bearer $TOKEN" \
+  "$BASE/projects/$PROJECT_ID/refresh"
+```
+
+## Bulk feed import
+
+```bash
+metatron seed-feeds my-project ./feeds.json
+```
+
+Where `feeds.json` is:
+```json
+{
+  "feeds": [
+    { "url": "https://hnrss.org/frontpage", "name": "Hacker News", "category": "tech" },
+    { "url": "https://www.theverge.com/rss/index.xml", "name": "The Verge", "category": "tech" }
+  ]
+}
+```
+
+## How dedup works
+
+Cheapest-to-most-expensive, short-circuits on first match:
+
+1. **Canonical URL.** Strip `utm_*`, `fbclid`, etc. Same canonical URL → exact duplicate, dropped.
+2. **Normalized title.** Lowercase, drop punctuation, strip newsroom prefixes ("BREAKING: ", "UPDATE - "). Same → joins the existing article's cluster.
+3. **Token overlap.** Jaccard similarity on title + summary tokens. ≥0.12 → shortlist candidate (top 5).
+4. **Sonnet tiebreaker.** Claude Sonnet reads both articles and decides "same story" or "different story." Same → joins cluster.
+
+Articles in a cluster are stored individually (you can see the alternative
+sources via `GET /articles/{id}`) but `/projects/{id}/articles` returns
+only the canonical from each cluster.
+
+## Storage
+
+Single SQLite file at `~/.local/share/metatron/metatron.db`. WAL mode, FK
+constraints on. Override with `[database].path` in config.
+
+## API endpoints
+
+| Method | Path                                  | Description                                  |
+|--------|---------------------------------------|----------------------------------------------|
+| GET    | `/health`                             | Liveness; reports LLM enablement             |
+| POST   | `/projects`                           | Create a project                             |
+| GET    | `/projects`                           | List projects                                |
+| DELETE | `/projects/{id}`                      | Delete a project (cascades feeds + articles) |
+| POST   | `/projects/{id}/feeds`                | Add a feed                                   |
+| GET    | `/projects/{id}/feeds`                | List feeds                                   |
+| DELETE | `/feeds/{id}`                         | Remove a feed                                |
+| GET    | `/projects/{id}/articles?since=&limit=` | List deduped articles                      |
+| POST   | `/projects/{id}/refresh`              | Synchronously poll project's feeds           |
+| GET    | `/articles/{id}`                      | Article detail + cluster members             |
+
+## Development
+
+```bash
+python3 -m pytest -q
+```
+
+Tests cover normalization, the DB layer, the dedup pipeline (with a fake
+LLM judge), the feed poller (with mocked RSS), and the API surface.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

metatron_cli-0.2.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+metatron/__init__.py,sha256=-akQUfUSR1OTezvy17U2ypfTqqiNxkesN0sp05kolQI,1108
+metatron/api.py,sha256=86WTtuJk2BezY0A-BFWySfiuGMwETuLs0DPFJU-3XrY,10514
+metatron/cli.py,sha256=K-356dfShXvuAKD20AOs4YCNAHvGfjTX6MNUtJvW03M,6920
+metatron/config.py,sha256=Vm-ChMODh3k7TvGm4GTRnVhXe1FQs_rFcSQvhYW2mKs,6232
+metatron/db.py,sha256=zmg8-ae95G0OOXWyJBPV1SCczXXKPJuOCcfrBJd5tE8,13377
+metatron/dedup.py,sha256=E3aRa251CGCxNzsgSI8DYCd8y8gxApqtgIbM0Gijsck,7263
+metatron/fetcher.py,sha256=HB9Am9O5SC8m2r7QHrZLkopu0uCih_wY23Jj3uSWoqc,4446
+metatron/llm.py,sha256=D7wmpT6EIWmtJZFlr6TI0dt0tG3c0aDQAXszZpjwLLQ,8800
+metatron/normalize.py,sha256=x0maVuzV2z2-hy-dZ1sjUh3HyuO3vni6vTIwcnQaJPQ,3787
+metatron/poller.py,sha256=veTDqqRUdIFrNIGh57TrM-sL-U_2EkBOd8YGkO3bagg,12067
+metatron_cli-0.2.1.dist-info/licenses/LICENSE,sha256=at8Cx79y_PI4PKS9hCrOYeN8XMhuUigTcFET3fcCWfU,1067
+metatron_cli-0.2.1.dist-info/METADATA,sha256=DvYSqGpC6f68ZdaiOan7VT9ttsJCskSPJF0pL7aE-2w,6129
+metatron_cli-0.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+metatron_cli-0.2.1.dist-info/entry_points.txt,sha256=tj_pczFcDHzV9UAsphXx2-APV4iyvhWH9xJBQx06KTM,47
+metatron_cli-0.2.1.dist-info/top_level.txt,sha256=xuqvlh66zVOuc8rmX0NCSGi9HnFxMadj0aNJ1jgxYeA,9
+metatron_cli-0.2.1.dist-info/RECORD,,

metatron_cli-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

metatron_cli-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+metatron = metatron.cli:main

metatron_cli-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matt Weber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

metatron_cli-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+metatron