diffbutler 0.5.0__py3-none-any.whl

diffbutler/core/setup.py

@@ -0,0 +1,232 @@
+"""First-run configuration with read-only forge validation; no database or AI operations."""
+
+import asyncio
+import logging
+import math
+import os
+import re
+import shutil
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from diffbutler.config.settings import (
+    NATIVE_PRESETS,
+    ConfigError,
+    Forge,
+    Reviewer,
+    Settings,
+    config_path,
+    load_settings,
+)
+from diffbutler.config.setup import save_setup
+from diffbutler.domain.forge import PRQuery, identity_part
+from diffbutler.forges.base import ForgeError
+from diffbutler.forges.github.setup import detect_login, repository_is_public, validate_access
+from diffbutler.sources.remotes import discover_repository
+
+SETUP_CHECK_TIMEOUT = 30.0
+
+
+async def startup_settings(
+    path: Path | None,
+    *,
+    directory: Path,
+    ask: Callable[[str, str], Awaitable[str]] | None,
+    progress: Callable[[str], None] | None = None,
+) -> Settings:
+    settings = await asyncio.to_thread(load_settings, path, missing_ok=True)
+    new_config = not (path or config_path()).expanduser().exists()
+
+    async def check[T](label: str, operation: Awaitable[T]) -> T:
+        logging.getLogger(__name__).info("Startup check: %s", label)
+        if progress is not None:
+            progress(label + "… (Ctrl+C to cancel)")
+        try:
+            async with asyncio.timeout(SETUP_CHECK_TIMEOUT):
+                return await operation
+        except TimeoutError:
+            raise ConfigError(
+                "Startup check timed out after 30 seconds; check network access and retry. "
+                "No setup changes were saved."
+            ) from None
+        except ForgeError as exc:
+            if exc.retry_after is not None:
+                delay = math.ceil(exc.retry_after)
+                raise ForgeError(
+                    f"GitHub requires a wait of {delay} seconds. Retry setup later; "
+                    "resetting DiffButler does not reset GitHub quota. "
+                    "No setup changes were saved.",
+                    status=exc.status,
+                    retry_after=exc.retry_after,
+                ) from None
+            raise
+
+    async def question(label: str, default: str = "") -> str:
+        if ask is None:
+            raise ConfigError(
+                "First-run setup requires more information; "
+                "start diffbutler in an interactive terminal or edit the config"
+            )
+        return (await ask(label, default)).strip()
+
+    if settings.forges:
+        reviewers, default = await setup_reviewer(
+            settings, directory, question, progress, discover=new_config
+        )
+        if default is not None:
+            await asyncio.to_thread(save_setup, path, None, None, reviewers, default)
+            return await asyncio.to_thread(load_settings, path)
+        return settings
+    detected = await check("Checking local repository", discover_repository(directory))
+
+    if detected is not None and detected.host == "github.com":
+        host = detected.host
+    else:
+        kind = (await question("Forge (github or github-enterprise)", "github")).lower()
+        if kind not in {"github", "github-enterprise"}:
+            raise ConfigError("Only GitHub and GitHub Enterprise are currently supported")
+        host = (
+            "github.com"
+            if kind == "github"
+            else await question("GitHub Enterprise hostname", detected.host if detected else "")
+        )
+    if not re.fullmatch(r"[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?", host):
+        raise ConfigError("Enter a forge hostname without a URL scheme or path")
+    host = host.lower()
+    matched = detected is not None and detected.host == host
+    repository = (
+        detected.repository
+        if detected is not None and matched
+        else await question("Repository to monitor (owner/name)")
+    )
+    try:
+        PRQuery(repository=repository)
+    except ValueError:
+        raise ConfigError("Repository must be owner/name") from None
+    base_url = "https://api.github.com" if host == "github.com" else f"https://{host}/api/v3"
+    public = await check(
+        "Checking GitHub repository visibility", repository_is_public(base_url, repository)
+    )
+    token_env: str | None = None
+    token: str | None = None
+    if progress is not None:
+        progress(
+            "Recommended: use your existing gh login with "
+            f'export GITHUB_TOKEN="$(gh auth token --hostname {host})".\n'
+            "Or create a fine-grained token at "
+            f"https://{host}/settings/personal-access-tokens "
+            "with repository permission Pull requests: Read-only.\n"
+            "Anonymous access is a last resort for public repositories: "
+            "GitHub.com allows only 60 requests/hour per IP."
+        )
+    access = "token"
+    if public:
+        access = (await question("GitHub access (token recommended, anonymous)", "token")).lower()
+        if access not in {"token", "anonymous"}:
+            raise ConfigError("Choose token or anonymous access")
+    if access == "token":
+        token_env = await question("GitHub token environment variable name", "GITHUB_TOKEN")
+        if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", token_env):
+            raise ConfigError("Enter an environment variable name, not a token value")
+        token = os.environ.get(token_env)
+        if not token:
+            raise ConfigError("The selected token environment variable is unset or empty")
+    login = (
+        await check("Detecting GitHub username", detect_login(base_url, token))
+        if token is not None
+        else None
+    )
+    if login is None:
+        login = await question("GitHub username for review requests", repository.split("/")[0])
+    else:
+        logging.getLogger(__name__).info("Detected GitHub username: %s", login)
+    try:
+        identity_part(login)
+    except ValueError:
+        raise ConfigError("Enter a valid GitHub username") from None
+    login = await check(
+        "Checking GitHub username and PR access",
+        validate_access(base_url, repository, login, token),
+    )
+    forge = Forge(
+        kind="github",
+        base_url=base_url,
+        token_env=token_env,
+        login=login,
+        include_team_requests=not public,
+        repositories=[repository],
+    )
+    reviewers, default = await setup_reviewer(
+        settings, directory, question, progress, discover=new_config
+    )
+    await asyncio.to_thread(
+        save_setup,
+        path,
+        forge,
+        detected.path if detected and matched else None,
+        reviewers,
+        default,
+    )
+    return await asyncio.to_thread(load_settings, path)
+
+
+async def check_reviewer(reviewer: Reviewer, directory: Path) -> None:
+    if shutil.which("git") is None:
+        raise ConfigError(
+            "Git is required to prepare PR sources; install Git and restart DiffButler"
+        )
+    if shutil.which(reviewer.command[0]) is None:
+        raise ConfigError("Reviewer executable was not found; install it or enter its full path")
+
+
+async def setup_reviewer(
+    settings: Settings,
+    directory: Path,
+    question: Callable[[str, str], Awaitable[str]],
+    progress: Callable[[str], None] | None = None,
+    *,
+    discover: bool = False,
+) -> tuple[tuple[Reviewer, ...], str | None]:
+    current = next(
+        (r for r in settings.reviewers if r.id == settings.review.default_reviewer), None
+    )
+    if current is not None and current.preset is not None:
+        return (), None
+    native = [r for r in settings.reviewers if r.preset is not None]
+    detected: list[Reviewer] = []
+    if discover and not settings.reviewers:
+        for preset in NATIVE_PRESETS:
+            if resolved := shutil.which(preset):
+                detected.append(
+                    Reviewer(id=preset, preset=preset, command=[str(Path(resolved).absolute())])
+                )
+        native = detected
+    if native:
+        choices = ", ".join(r.id for r in native)
+        name = await question(f"Default AI reviewer ({choices})", native[0].id)
+        chosen = next((r for r in native if r.id == name), None)
+        if chosen is None:
+            raise ConfigError("Choose one of the configured native reviewers")
+        if progress is not None:
+            progress("Checking Git and reviewer executable… (Ctrl+C to cancel)")
+        await check_reviewer(chosen, directory)
+        return tuple(detected), chosen.id
+    name = (await question("AI reviewer (codex or claude)", "codex")).lower()
+    if name not in {"codex", "claude"}:
+        raise ConfigError("Choose codex or claude as the AI reviewer")
+    executable = await question("Reviewer executable (name or full path)", name)
+    resolved = shutil.which(executable)
+    if resolved is None:
+        raise ConfigError("Reviewer executable was not found; install it or enter its full path")
+    identifier = name
+    while any(r.id == identifier for r in settings.reviewers):
+        identifier += "-native"
+    reviewer = Reviewer(
+        id=identifier,
+        command=[str(Path(resolved).absolute())],
+        preset="codex" if name == "codex" else "claude",
+    )
+    if progress is not None:
+        progress("Checking Git and reviewer executable… (Ctrl+C to cancel)")
+    await check_reviewer(reviewer, directory)
+    return (reviewer,), reviewer.id

diffbutler/core/snapshot.py

@@ -0,0 +1,70 @@
+"""Materialize pinned, redacted Git blobs as text/data, never run checkout hooks."""
+
+import logging
+import time
+from collections.abc import Callable
+from contextlib import aclosing
+from pathlib import Path
+
+from diffbutler.domain.redaction import redact_source
+from diffbutler.domain.review import Side, SourceFile
+from diffbutler.reviewers.resources import settled_io
+from diffbutler.sources.git import GitSourceReader
+
+
+async def write_snapshot(
+    reader: GitSourceReader,
+    destination: Path,
+    *,
+    progress: Callable[[str], None] | None = None,
+) -> None:
+    """Stream unique blobs into a new owned directory, with one redaction per blob.
+
+    Symlinks become regular files containing link text; submodules fail. Files
+    are independent copies, without Git administration or executable modes.
+    """
+    total = sum(len(reader.paths(side)) for side in Side)
+    completed = objects = redactions = 0
+    started = last_report = time.monotonic()
+
+    def report() -> None:
+        message = f"Preparing source snapshots: {completed}/{total} files ({objects} unique blobs)"
+        logging.getLogger(__name__).info("%s", message)
+        if progress is not None:
+            progress(message)
+
+    report()
+
+    def initialize() -> None:
+        destination.mkdir(mode=0o700)
+        for side in Side:
+            (destination / side.value).mkdir(mode=0o700)
+
+    await settled_io(initialize)
+    async with aclosing(reader.read_blobs()) as blobs:
+        async for sources, content in blobs:
+
+            def write(sources: tuple[SourceFile, ...] = sources, content: bytes = content) -> int:
+                redacted = redact_source(content)
+                for source in sources:
+                    target = destination / source.side.value / source.path
+                    target.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+                    with target.open("xb") as stream:
+                        stream.write(redacted.content)
+                    target.chmod(0o600)
+                return redacted.count
+
+            redactions += await settled_io(write)
+            completed += len(sources)
+            objects += 1
+            if time.monotonic() - last_report >= 5:
+                report()
+                last_report = time.monotonic()
+    report()
+    logging.getLogger(__name__).info(
+        "Source snapshots ready: files=%d blobs=%d masked=%d elapsed_s=%.3f",
+        completed,
+        objects,
+        redactions,
+        time.monotonic() - started,
+    )

diffbutler/core/sync.py

@@ -0,0 +1,259 @@
+"""Shared async discovery, follow-up, and browsing services; no reviewer capability."""
+
+from dataclasses import replace
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+from diffbutler.domain.forge import Account, Discovery, PRPage, PRQuery, PRRef
+from diffbutler.domain.sync import ReviewActivity, TrackedPR, reconcile
+from diffbutler.forges.base import ForgeError, ReadForge
+from diffbutler.store.base import QueueStore, SyncConflict
+
+
+class PullRequestRow(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    account: Account
+    tracked: TrackedPR
+    warnings: tuple[str, ...] = ()
+
+
+class SyncReport(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    account: Account
+    discovered: int
+    refreshed: int
+    active: int
+    complete: bool
+    warnings: tuple[str, ...]
+
+
+class DiffButler:
+    def __init__(
+        self,
+        store: QueueStore,
+        forge: ReadForge,
+        *,
+        expected_login: str | None = None,
+        monitor_repositories: tuple[str, ...] = (),
+    ):
+        self.store = store
+        self.forge = forge
+        self.expected_login = expected_login
+        self.monitor_repositories = monitor_repositories
+
+    async def _account(self) -> Account:
+        account = await self.forge.whoami()
+        if account.forge != self.forge.id or (
+            self.expected_login is not None and account.login.lower() != self.expected_login.lower()
+        ):
+            raise ForgeError("Authenticated identity does not match configured account")
+        return account
+
+    async def sync(self) -> SyncReport:
+        account = await self._account()
+        stale_results: dict[PRRef, TrackedPR] = {}
+        for attempt in range(3):
+            snapshot = await self.store.snapshot(account)
+            try:
+                discovery = await self.forge.list_review_requests()
+            except ForgeError as exc:
+                discovery = Discovery((), False, (f"Discovery failed: {exc}",))
+            warnings = list(discovery.warnings)
+            complete = discovery.complete
+            discovered = {item.pull_request.ref: item.pull_request for item in discovery.items}
+            sources: dict[PRRef, set[str]] = {}
+            for item in discovery.items:
+                sources.setdefault(item.pull_request.ref, set()).update(item.sources)
+            # Broad monitoring is independent of review-request membership.
+            for repository in self.monitor_repositories:
+                cursor: str | None = None
+                seen: set[str] = set()
+                try:
+                    while True:
+                        page = await self.forge.search_pull_requests(
+                            PRQuery(repository=repository, page_size=100), cursor
+                        )
+                        complete = complete and page.complete
+                        warnings.extend(page.warnings)
+                        for pr in page.items:
+                            if (
+                                pr.state == "open"
+                                and pr.ref.forge == account.forge
+                                and f"{pr.ref.namespace}/{pr.ref.repository}".lower()
+                                == repository.lower()
+                            ):
+                                discovered[pr.ref] = pr
+                        cursor = page.next_cursor
+                        if cursor is None:
+                            break
+                        if cursor in seen:
+                            raise ForgeError("Repeated pagination cursor")
+                        seen.add(cursor)
+                except ForgeError as exc:
+                    complete = False
+                    warnings.append(f"Open-PR monitoring is incomplete: {exc}")
+            previous = {item.pull_request.ref: item for item in snapshot.items}
+            refs = set(discovered) | {
+                ref
+                for ref, item in previous.items()
+                if item.following and item.pull_request.state == "open"
+            }
+            updated = dict(previous)
+            refreshed: set[PRRef] = set()
+            for ref in sorted(
+                refs, key=lambda ref: (ref.forge, ref.namespace, ref.repository, ref.number)
+            ):
+                old = previous.get(ref)
+                stale = stale_results.get(ref)
+                if old and stale and old.manual_after != stale.manual_after:
+                    # Consume evidence fetched before a newer manual choice, even
+                    # if the forge's clock is ahead of this host's clock.
+                    old = replace(old, manual_after=max(old.manual_after, stale.review_key))
+                membership = set(sources.get(ref, ()))
+                if not discovery.complete and old:
+                    membership.update(old.sources)
+                try:
+                    # Followed PRs refresh by identity even when search is empty or stale.
+                    pr = await self.forge.get_pull_request(ref) if old else discovered[ref]
+                    if pr.ref != ref:
+                        raise ForgeError("Forge returned a different PR identity")
+                except ForgeError as exc:
+                    complete = False
+                    warnings.append(
+                        f"Could not refresh {ref.namespace}/{ref.repository}#{ref.number}: {exc}"
+                    )
+                    if old:
+                        updated[ref] = replace(
+                            old, sources=tuple(sorted(membership)), refresh_pending=True
+                        )
+                    continue
+                try:
+                    activity = await self.forge.get_review_activity(ref)
+                    if activity.account != account:
+                        raise ForgeError("Account changed during activity refresh")
+                except ForgeError as exc:
+                    activity = ReviewActivity(account, complete=False, warnings=(str(exc),))
+                complete = complete and activity.complete
+                warnings.extend(activity.warnings)
+                updated[ref] = reconcile(old, pr, activity, tuple(sorted(membership)))
+                refreshed.add(ref)
+            # Clear stale membership only after complete discovery, including closed monitors.
+            if discovery.complete:
+                for ref, item in updated.items():
+                    if ref not in refs:
+                        updated[ref] = replace(item, sources=tuple(sorted(sources.get(ref, ()))))
+            if await self._account() != account:
+                raise ForgeError("Account changed during sync; no changes saved")
+            try:
+                await self.store.apply(
+                    account,
+                    snapshot.version,
+                    tuple(updated.values()),
+                    refreshed=frozenset(refreshed),
+                )
+            except SyncConflict:
+                stale_results = updated
+                if attempt == 2:
+                    raise ForgeError("Queue changed concurrently; retry sync") from None
+                continue
+            return SyncReport(
+                account=account,
+                discovered=len(discovered),
+                refreshed=len(refreshed),
+                active=sum(item.state != "DONE" for item in updated.values()),
+                complete=complete,
+                warnings=tuple(dict.fromkeys(warnings)),
+            )
+        raise AssertionError("unreachable")
+
+    async def follow_pr(self, ref: PRRef) -> PullRequestRow:
+        account = await self._account()
+        stale: TrackedPR | None = None
+        for attempt in range(3):
+            snapshot = await self.store.snapshot(account)
+            previous = next((item for item in snapshot.items if item.pull_request.ref == ref), None)
+            if previous and stale and previous.manual_after != stale.manual_after:
+                previous = replace(
+                    previous, manual_after=max(previous.manual_after, stale.review_key)
+                )
+            pr = await self.forge.get_pull_request(ref)
+            if pr.ref != ref:
+                raise ForgeError("Forge returned a different PR identity")
+            # Following succeeds even if activity access fails; return the warning to the UI.
+            try:
+                activity = await self.forge.get_review_activity(ref)
+            except ForgeError as exc:
+                activity = ReviewActivity(account, complete=False, warnings=(str(exc),))
+            if activity.account != account or await self._account() != account:
+                raise ForgeError("Account changed during follow; no changes saved")
+            item = reconcile(previous, pr, activity, previous.sources if previous else ())
+            item = replace(item, following=True)
+            try:
+                await self.store.apply(
+                    account, snapshot.version, (item,), refreshed=frozenset({ref})
+                )
+            except SyncConflict:
+                stale = item
+                if attempt == 2:
+                    raise ForgeError("Queue changed concurrently; retry follow") from None
+                continue
+            persisted = await self.store.snapshot(account)
+            result = next(row for row in persisted.items if row.pull_request.ref == ref)
+            return PullRequestRow(account=account, tracked=result, warnings=activity.warnings)
+        raise AssertionError("unreachable")
+
+    async def browse_prs(self, query: PRQuery, cursor: str | None = None) -> PRPage:
+        await self._account()
+        return await self.forge.search_pull_requests(query, cursor)
+
+
+async def list_queue(
+    store: QueueStore,
+    *,
+    view: Literal["active", "requested", "following"] = "active",
+    login: str | None = None,
+    include_own_prs: bool = False,
+    include_assigned_prs: bool = False,
+) -> tuple[PullRequestRow, ...]:
+    """Read local accounts without resolving credentials or making network requests."""
+    rows: list[PullRequestRow] = []
+    for account in await store.accounts():
+        if login is not None and account.login.lower() != login.lower():
+            continue
+        for item in (await store.snapshot(account)).items:
+            if (
+                not include_own_prs
+                and item.pull_request.author.casefold() == account.login.casefold()
+            ):
+                continue
+            if not include_assigned_prs and any(
+                assignee.casefold() == account.login.casefold()
+                for assignee in item.pull_request.assignees
+            ):
+                continue
+            include = (
+                item.state != "DONE"
+                if view == "active"
+                else any(
+                    source == f"user:{account.login.lower()}" or source.startswith("team:")
+                    for source in item.sources
+                )
+                if view == "requested"
+                else item.following
+            )
+            if include:
+                rows.append(PullRequestRow(account=account, tracked=item))
+    return tuple(
+        sorted(
+            rows,
+            key=lambda row: (
+                row.tracked.state == "DONE_PLUS",
+                row.account.forge,
+                row.account.login,
+                row.tracked.pull_request.ref.namespace,
+                row.tracked.pull_request.ref.repository,
+                row.tracked.pull_request.ref.number,
+            ),
+        )
+    )