alissa-tools-github-revloop 0.12.0__py3-none-any.whl

alissa/tools/github/revloop/proc.py

@@ -0,0 +1,56 @@
+"""Subprocess helpers. Everything shells out to `gh` and `alissa` so both keep
+their own auth handling; we never touch tokens ourselves."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from typing import Sequence
+
+log = logging.getLogger(__name__)
+
+
+class CommandError(RuntimeError):
+    def __init__(self, argv: Sequence[str], returncode: int, stderr: str):
+        self.argv = list(argv)
+        self.returncode = returncode
+        self.stderr = stderr
+        super().__init__(f"{argv[0]} exited {returncode}: {stderr.strip()[:400]}")
+
+
+def run(
+    argv: Sequence[str],
+    *,
+    timeout: int = 60,
+    check: bool = True,
+    cwd: "str | os.PathLike[str] | None" = None,
+) -> str:
+    """Run a command, return stdout. Never uses shell=True."""
+    log.debug("exec: %s", " ".join(argv))
+    try:
+        proc = subprocess.run(
+            list(argv),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=str(cwd) if cwd is not None else None,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise CommandError(argv, -1, f"timed out after {timeout}s") from exc
+
+    if check and proc.returncode != 0:
+        raise CommandError(argv, proc.returncode, proc.stderr)
+    return proc.stdout
+
+
+def run_json(argv: Sequence[str], *, timeout: int = 60):
+    """Run a command whose stdout is JSON."""
+    out = run(argv, timeout=timeout).strip()
+    if not out:
+        return None
+    try:
+        return json.loads(out)
+    except json.JSONDecodeError as exc:
+        raise CommandError(argv, 0, f"expected JSON, got: {out[:300]}") from exc

alissa/tools/github/revloop/prreview.py

@@ -0,0 +1,228 @@
+"""alissa-pr-review: the implementer-side driver for ONE review round.
+
+The reviewer daemon (`alissa-revloop`) is autonomous but only the *reviewer*
+half: a review request in, a review out. This command is the *implementer* half,
+run by the dev session that just finished the work — it fires the trigger and
+blocks on the verdict, so the loop closes without a second always-on daemon.
+
+One invocation = one round:
+
+  1. resolve the PR from the branch
+  2. flip it ready-for-review (from draft)
+  3. request the reviewer          ← this is the daemon's edge-trigger
+  4. block until a NEW review round lands, or the timeout
+
+It reads the verdict from the **review task envelope**, never from GitHub's
+review state: reviewers work in comment mode, so the GitHub state is always
+COMMENTED and cannot express approval. The round-completion signal is the
+reviewer's substantive-review count going up; the verdict word then comes from
+`Alissa.latest_verdict` — the exact logic the daemon uses, so the two halves
+cannot disagree.
+
+The triage -> fix -> re-enter loop and the round cap live in the caller (see the
+`run-the-review-loop` how-to): on `request_changes` the dev triages, fixes, and
+runs this again for round k+1.
+
+Exit codes:  0 approve · 1 request_changes · 2 timeout/no verdict · 3 usage/setup
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import re
+import sys
+import time
+
+from .alissa import Alissa, VERDICT_APPROVE, VERDICT_REQUEST_CHANGES
+from .ghclient import GitHub
+from .proc import CommandError, run, run_json
+
+log = logging.getLogger(__name__)
+
+# After a new review lands, the verdict envelope is written on the task around
+# the same moment; give it a short grace window to appear before giving up.
+_ENVELOPE_GRACE_SECONDS = 120
+
+
+def resolve_pr(branch: str | None) -> tuple[str, str, int, str, bool]:
+    """(owner, repo, number, url, is_draft) for `branch` (or the current branch).
+
+    Runs in the repo working tree, so `gh` infers the repo; the head branch
+    selects the PR. owner/repo come from the PR URL, which is the base repo.
+    """
+    argv = ["gh", "pr", "view"]
+    if branch:
+        argv.append(branch)
+    argv += ["--json", "url,number,isDraft,state"]
+    data = run_json(argv)
+    if not data:
+        raise ValueError(
+            f"no pull request found for {'branch ' + branch if branch else 'the current branch'}"
+        )
+    url = data.get("url", "")
+    match = re.search(r"github\.com/([\w.-]+)/([\w.-]+)/pull/(\d+)", url)
+    if not match:
+        raise ValueError(f"could not parse owner/repo from PR url {url!r}")
+    if data.get("state") not in (None, "OPEN"):
+        raise ValueError(f"PR {url} is {data.get('state')}, not open — nothing to review")
+    return match.group(1), match.group(2), int(match.group(3)), url, bool(data.get("isDraft"))
+
+
+def _review_task_ref(alissa: Alissa, owner: str, repo: str, number: int) -> str | None:
+    """The CR2 review task for this PR, by title, regardless of status.
+
+    Deliberately not `Alissa.find_review_task` (which filters to open tasks): we
+    still want the ref just after the task is validated, to read its verdict.
+    """
+    pattern = re.compile(
+        rf"^Review PR\s+{re.escape(owner)}/{re.escape(repo)}#{number}\b", re.IGNORECASE
+    )
+    matches = [t for t in alissa.list_tasks() if pattern.match(t.title)]
+    return matches[0].ref if matches else None
+
+
+def _reviewer_review_count(gh: GitHub, owner: str, repo: str, number: int, reviewer: str) -> int:
+    """Substantive reviews the reviewer has submitted — one per completed round.
+
+    Same 'substantive' rule the daemon counts by (empty-bodied inline-comment
+    artifacts don't close a round), so a fresh round is a clean +1 edge.
+    """
+    return sum(
+        1
+        for r in gh.reviews(owner, repo, number)
+        if r.author == reviewer and r.is_substantive
+    )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="alissa-pr-review",
+        description="Implementer-side: flip a PR ready, request a reviewer, and "
+        "block until the review verdict lands (one round of the adversarial loop).",
+    )
+    p.add_argument(
+        "--reviewer",
+        required=True,
+        metavar="LOGIN",
+        help="GitHub login to request review from (e.g. alissa-app)",
+    )
+    p.add_argument(
+        "--branch",
+        metavar="NAME",
+        help="head branch of the PR (default: the current branch)",
+    )
+    p.add_argument(
+        "--timeout",
+        type=int,
+        default=2700,
+        metavar="SECONDS",
+        help="give up waiting after this long (default: 2700 = 45 min)",
+    )
+    p.add_argument(
+        "--poll-interval",
+        type=int,
+        default=30,
+        metavar="SECONDS",
+        help="seconds between checks (default: 30)",
+    )
+    p.add_argument("-v", "--verbose", action="store_true")
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(levelname)-7s %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    gh = GitHub()
+    alissa = Alissa()
+
+    try:
+        # Identity guard: GitHub forbids requesting review from the PR author, so
+        # the dev's gh token must not be the reviewer.
+        dev = gh.token_login()
+        if dev == args.reviewer:
+            print(
+                f"identity error: the gh token belongs to {dev!r}, the same as "
+                f"--reviewer. GitHub forbids requesting review from the PR author; "
+                f"run this as a different account than the reviewer.",
+                file=sys.stderr,
+            )
+            return 3
+
+        owner, repo, number, url, is_draft = resolve_pr(args.branch)
+        slug = f"{owner}/{repo}#{number}"
+        log.info("PR %s (%s), reviewing as reviewer=%s, dev=%s", slug, url, args.reviewer, dev)
+
+        if is_draft:
+            log.info("flipping %s ready-for-review", slug)
+            run(["gh", "pr", "ready", str(number)])
+
+        before = _reviewer_review_count(gh, owner, repo, number, args.reviewer)
+        log.info("requesting review from %s (round %d)", args.reviewer, before + 1)
+        run(["gh", "pr", "edit", str(number), "--add-reviewer", args.reviewer])
+
+        deadline = time.time() + args.timeout
+        ref: str | None = None
+        round_landed_at: float | None = None
+
+        while time.time() < deadline:
+            time.sleep(args.poll_interval)
+
+            if round_landed_at is None:
+                now = _reviewer_review_count(gh, owner, repo, number, args.reviewer)
+                if now > before:
+                    round_landed_at = time.time()
+                    log.info("%s: a new review landed — reading the verdict", slug)
+                else:
+                    log.debug("%s: still waiting (reviews=%d)", slug, now)
+                    continue
+
+            ref = ref or _review_task_ref(alissa, owner, repo, number)
+            verdict = alissa.latest_verdict(ref) if ref else None
+            if verdict == VERDICT_APPROVE:
+                print(f"\n✔ APPROVE — {slug} converged.\n  PR:   {url}\n  task: {ref}")
+                return 0
+            if verdict == VERDICT_REQUEST_CHANGES:
+                print(
+                    f"\n✗ REQUEST_CHANGES — {slug}.\n  PR:   {url}\n  task: {ref}\n"
+                    f"  Triage each finding on its PR thread, fix, then run this again "
+                    f"for the next round."
+                )
+                return 1
+
+            # Review landed but the envelope isn't readable yet — brief grace.
+            if round_landed_at and time.time() - round_landed_at > _ENVELOPE_GRACE_SECONDS:
+                print(
+                    f"\n⚠ a review landed on {slug} but no verdict envelope was found "
+                    f"on the review task {ref or '(not found)'} within "
+                    f"{_ENVELOPE_GRACE_SECONDS}s.\n  PR: {url}\n  Read the PR review "
+                    f"and the review task directly.",
+                    file=sys.stderr,
+                )
+                return 2
+
+        print(
+            f"\n⏱ timed out after {args.timeout}s waiting for a review on {slug} — no "
+            f"verdict yet.\n  PR: {url}\n  The reviewer daemon re-spawns a stalled "
+            f"reviewer at ~90 min; re-run this, or check the worker.",
+            file=sys.stderr,
+        )
+        return 2
+
+    except CommandError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 3
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 3
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

alissa/tools/github/revloop/state.py

@@ -0,0 +1,218 @@
+"""Local spawn ledger.
+
+Deliberately thin: GitHub is the source of truth for how many rounds have run
+(one submitted review per round). This table exists only to stop the daemon
+double-spawning a reviewer while a round is still in flight, to map a live
+session name back to the round it was spawned for (so the reap sweep can tell
+a finished round's session from an in-flight one), and to remember that a
+cap-out was already escalated. The ledger tolerates sessions dying or being
+killed behind its back: a reap record is bookkeeping, never a precondition.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from pathlib import Path
+
+# Shared between SCHEMA and the migration so the two can never drift.
+_SPAWNS_TABLE = """
+CREATE TABLE IF NOT EXISTS spawns (
+    repo       TEXT    NOT NULL,
+    number     INTEGER NOT NULL,
+    round      INTEGER NOT NULL,
+    head_sha   TEXT    NOT NULL,
+    session    TEXT    NOT NULL PRIMARY KEY,
+    task_ref   TEXT,
+    spawned_at INTEGER NOT NULL
+)"""
+
+SCHEMA = f"""
+{_SPAWNS_TABLE};
+
+CREATE INDEX IF NOT EXISTS spawns_by_round ON spawns (repo, number, round);
+
+CREATE TABLE IF NOT EXISTS escalations (
+    repo         TEXT    NOT NULL,
+    number       INTEGER NOT NULL,
+    head_sha     TEXT    NOT NULL,
+    escalated_at INTEGER NOT NULL,
+    PRIMARY KEY (repo, number, head_sha)
+);
+
+CREATE TABLE IF NOT EXISTS reaps (
+    session   TEXT    NOT NULL PRIMARY KEY,
+    reaped_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS pings (
+    repo      TEXT    NOT NULL,
+    number    INTEGER NOT NULL,
+    kind      TEXT    NOT NULL,
+    pinged_at INTEGER NOT NULL,
+    PRIMARY KEY (repo, number, kind)
+);
+"""
+
+
+class State:
+    def __init__(self, path: Path):
+        path = Path(path).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self._db = sqlite3.connect(str(path))
+        self._db.row_factory = sqlite3.Row
+        if self._spawns_keyed_by_round():
+            self._migrate_spawns()
+        self._db.executescript(SCHEMA)
+        self._db.commit()
+
+    def _migrate_spawns(self) -> None:
+        """Re-key an old round-keyed `spawns` by session, in ONE transaction.
+
+        Deliberately not executescript (it COMMITs the open transaction before
+        running): a crash between the rename and the copy would otherwise
+        leave an empty new `spawns` that no longer looks stale, stranding
+        every row in spawns_v0 — an empty ledger makes the sweep spare every
+        live session as "not ours". All-or-nothing instead: any failure rolls
+        back to the untouched old table and the next open retries.
+        """
+        self._db.execute("BEGIN IMMEDIATE")
+        try:
+            self._db.execute("ALTER TABLE spawns RENAME TO spawns_v0")
+            self._db.execute(_SPAWNS_TABLE)
+            self._db.execute(
+                "INSERT OR REPLACE INTO spawns "
+                "(repo, number, round, head_sha, session, task_ref, spawned_at) "
+                "SELECT repo, number, round, head_sha, session, task_ref, spawned_at "
+                "FROM spawns_v0"
+            )
+            self._db.execute("DROP TABLE spawns_v0")
+        except BaseException:
+            self._db.execute("ROLLBACK")
+            raise
+        self._db.execute("COMMIT")
+
+    def _spawns_keyed_by_round(self) -> bool:
+        """True when `spawns` still has the pre-0.8 (repo, number, round) key.
+
+        That key made `record_spawn` overwrite the row when a stalled round
+        was re-enqueued, orphaning the original -- possibly still-live --
+        session so the reap sweep spared it forever as "not ours". The key is
+        now the session name (unique per spawn, thanks to the nonce). SQLite
+        cannot alter a primary key in place, so an old table is renamed and
+        copied over exactly once on open.
+        """
+        info = self._db.execute("PRAGMA table_info(spawns)").fetchall()
+        if not info:
+            return False  # fresh database, nothing to migrate
+        return [r["name"] for r in info if r["pk"]] != ["session"]
+
+    def close(self) -> None:
+        self._db.close()
+
+    def __enter__(self) -> "State":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    def get_spawn(self, repo: str, number: int, round_: int) -> sqlite3.Row | None:
+        """The NEWEST spawn recorded for this round, or None.
+
+        A stalled round can be re-enqueued, so one round may have several
+        spawns; aging and the in-flight check are about the latest attempt.
+        """
+        return self._db.execute(
+            "SELECT * FROM spawns WHERE repo=? AND number=? AND round=? "
+            "ORDER BY spawned_at DESC, rowid DESC LIMIT 1",
+            (repo, number, round_),
+        ).fetchone()
+
+    def find_spawn_by_session(self, session: str) -> sqlite3.Row | None:
+        """The spawn a live session name belongs to, or None if it is not ours.
+
+        Session names carry a random nonce, so a name maps to at most one
+        spawn. The reap sweep starts from live tmux state and uses this to
+        recover (repo, number, round); a session with no row (another
+        workspace's daemon, or a hand-started one) is not ours to judge.
+        """
+        return self._db.execute(
+            "SELECT * FROM spawns WHERE session=?", (session,)
+        ).fetchone()
+
+    def spawn_age(self, repo: str, number: int, round_: int) -> float | None:
+        """Seconds since round `round_` was enqueued, or None if never spawned."""
+        row = self.get_spawn(repo, number, round_)
+        return None if row is None else time.time() - row["spawned_at"]
+
+    def record_spawn(
+        self,
+        *,
+        repo: str,
+        number: int,
+        round_: int,
+        head_sha: str,
+        session: str,
+        task_ref: str | None,
+    ) -> None:
+        self._db.execute(
+            "INSERT OR REPLACE INTO spawns "
+            "(repo, number, round, head_sha, session, task_ref, spawned_at) "
+            "VALUES (?,?,?,?,?,?,?)",
+            (repo, number, round_, head_sha, session, task_ref, int(time.time())),
+        )
+        self._db.commit()
+
+    def is_reaped(self, session: str) -> bool:
+        row = self._db.execute(
+            "SELECT 1 FROM reaps WHERE session=?", (session,)
+        ).fetchone()
+        return row is not None
+
+    def record_reap(self, session: str) -> None:
+        self._db.execute(
+            "INSERT OR REPLACE INTO reaps (session, reaped_at) VALUES (?,?)",
+            (session, int(time.time())),
+        )
+        self._db.commit()
+
+    def pinged(self, repo: str, number: int, kind: str) -> bool:
+        """Whether this KIND of operator ping already went out for the PR.
+
+        Kind is free-form TEXT (devloop's escalation-kind pattern): a caller
+        narrows a kind's dedupe scope by folding identity into the string --
+        e.g. one stalled ping per deferral episode, "stalled:<session>" (see
+        loop.stalled_kind). Kept apart from `escalations`, whose key is
+        (repo, number, head_sha) and whose rows page terminal states.
+        """
+        row = self._db.execute(
+            "SELECT 1 FROM pings WHERE repo=? AND number=? AND kind=?",
+            (repo, number, kind),
+        ).fetchone()
+        return row is not None
+
+    def record_ping(self, repo: str, number: int, kind: str) -> None:
+        """Idempotent per kind: OR IGNORE keeps the FIRST ping's timestamp,
+        so `pinged_at` is an audit field for when the episode was first
+        raised, not the most recent re-raise."""
+        self._db.execute(
+            "INSERT OR IGNORE INTO pings (repo, number, kind, pinged_at) "
+            "VALUES (?,?,?,?)",
+            (repo, number, kind, int(time.time())),
+        )
+        self._db.commit()
+
+    def escalated(self, repo: str, number: int, head_sha: str) -> bool:
+        row = self._db.execute(
+            "SELECT 1 FROM escalations WHERE repo=? AND number=? AND head_sha=?",
+            (repo, number, head_sha),
+        ).fetchone()
+        return row is not None
+
+    def record_escalation(self, repo: str, number: int, head_sha: str) -> None:
+        self._db.execute(
+            "INSERT OR REPLACE INTO escalations "
+            "(repo, number, head_sha, escalated_at) VALUES (?,?,?,?)",
+            (repo, number, head_sha, int(time.time())),
+        )
+        self._db.commit()

alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.12.0

alissa/tools/github/revloop/version.py

@@ -0,0 +1,46 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class Version:
+    name: str
+    value: str
+
+    def components(self, as_int: bool = False) -> list:
+        return [int(val) if as_int else val for val in self.value.split(".")]
+
+    @property
+    def major(self) -> int:
+        component, *_ = self.components(as_int=True)
+        return component
+
+    @property
+    def minor(self) -> int:
+        _, component, *_ = self.components(as_int=True)
+        return component
+
+    @property
+    def patch(self) -> int:
+        *_, component = self.components(as_int=True)
+        return component
+
+    @classmethod
+    def from_path(cls, dirpath: str, name: str):
+        for file in os.listdir(dirpath):
+            if file.lower().endswith("version"):
+                filepath = os.path.join(dirpath, file)
+                break
+        else:
+            raise ValueError("Version file not found for package name: " + name)
+
+        with open(filepath, "r") as version_file:
+            version_value = version_file.readline().strip()
+            return cls(name=name, value=version_value)
+
+
+try:
+    version = Version.from_path(name="alissa-tools-github-revloop", dirpath=os.path.dirname(__file__))
+except Exception:
+    print("Version file not found for package name: alissa-tools-github-revloop, using 0.0.0")
+    version = Version(name="alissa-tools-github-revloop", value="0.0.0")

alissa_tools_github_revloop-0.12.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: alissa-tools-github-revloop
+Version: 0.12.0
+Summary: ALISSA-TOOLS-GITHUB-REVLOOP
+Home-page: https://alissa.app
+Author: Fahera
+Author-email: support@alissa.app
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# alissa-tools-github-revloop
+
+The `alissa.tools.github.revloop` module: a GitHub watcher that drives the
+`alissa-code-review` adversarial review loop (CR1–CR9) to convergence.
+
+This distribution ships **only** that module. Everything above it —
+`alissa`, `alissa.tools`, `alissa.tools.github` — is a
+[PEP 420](https://peps.python.org/pep-0420/) namespace package with no
+`__init__.py`, so other distributions in other repositories can contribute
+their own packages under the same namespace:
+
+```
+alissa/                                  ← namespace (no __init__.py)
+└── tools/                               ← namespace
+    ├── github/                          ← namespace
+    │   ├── revloop/   __init__.py    ← THIS distribution
+    │   └── issues/       __init__.py    ← could ship from another repo
+    └── slack/                           ← namespace
+        └── notify/       __init__.py    ← could ship from another repo
+```
+
+The rule: a distribution owns a leaf package and declares only that subtree
+(`find_namespace_packages(include=[PACKAGE, f"{PACKAGE}.*"])`). Adding an
+`__init__.py` at any namespace level would claim it for one distribution and
+shadow the others.
+
+## Install
+
+```sh
+pip install -e ./alissa-tools-github-revloop
+```
+
+## Console scripts
+
+| Command | Entry point |
+| --- | --- |
+| `alissa-revloop` | `alissa.tools.github.revloop.__main__:main` |
+
+## Layout
+
+`src/main` holds the package tree, `src/test` mirrors it as `test_*`. The
+distribution version lives in the plain-text `version` file next to the module
+it versions (`src/main/alissa/tools/github/revloop/version`), read by both
+`setup.py` and `version.py`.

alissa_tools_github_revloop-0.12.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+alissa/tools/github/revloop/__init__.py,sha256=dIjcycNDlYaqaOvMkYIfv6QaLo5nLP_0RXqORpWvKhM,283
+alissa/tools/github/revloop/__main__.py,sha256=mdSFZWBZnulCk8RjkQDa1XMji1_AfODoqWnPk53-wW8,6009
+alissa/tools/github/revloop/alissa.py,sha256=DGuLlsU4epmu-C8g96sMFxZ8s6OVFsMoTxFmUCkdDtw,12255
+alissa/tools/github/revloop/config.py,sha256=cEHmLsV9UCveZYHN_wHY24eWhU31rZQIbOS6VXAqBU4,7607
+alissa/tools/github/revloop/ghclient.py,sha256=T45uEpkNUb6CJBNk9hJwyiMn5p7iBJaTm_r3-senzRc,8927
+alissa/tools/github/revloop/loop.py,sha256=-82QgNChrNzhnlAks68gqjuumb_1iqPPFbXSUAyPqLs,37763
+alissa/tools/github/revloop/proc.py,sha256=_dDr3g76WEf2DRyLUz1Dzl4KvLVptJant_UZOrRixNk,1649
+alissa/tools/github/revloop/prreview.py,sha256=A0VLyQUIkPYXvZ8cS8vBS9S-2FYOhZxRdSuQwmefIYw,8800
+alissa/tools/github/revloop/state.py,sha256=T113BhMAPBJsIEurJTZ1t9moZdfocl_Q2LQvvZoCQ_0,8356
+alissa/tools/github/revloop/version,sha256=23I3BXwGze7GmNOWUDs5Kkuc7-uKYuNyerA4U3A-rNo,6
+alissa/tools/github/revloop/version.py,sha256=cWVOK4zFuZ3jOswsR2SNghJrUHeC08ftxOECtE4DFtA,1418
+alissa_tools_github_revloop-0.12.0.dist-info/METADATA,sha256=hLlUeSTblMHDuUYA6Kg0QC5X-i4LBPGKbO9b2E8dE_o,2110
+alissa_tools_github_revloop-0.12.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+alissa_tools_github_revloop-0.12.0.dist-info/entry_points.txt,sha256=bdTgjQMnI1dGdEluuAewEDfQSIwzn66MXaWGeFrfXdE,138
+alissa_tools_github_revloop-0.12.0.dist-info/top_level.txt,sha256=DodjDg-l-TWQnlxG-Vuc3G5sB4O7cWGQwe6XrVx3u-A,7
+alissa_tools_github_revloop-0.12.0.dist-info/RECORD,,

alissa_tools_github_revloop-0.12.0.dist-info/WHEEL

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

alissa_tools_github_revloop-0.12.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+alissa-pr-review = alissa.tools.github.revloop.prreview:main
+alissa-revloop = alissa.tools.github.revloop.__main__:main

alissa_tools_github_revloop-0.12.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+alissa