diffbutler 0.5.0__py3-none-any.whl

diffbutler/config/transport.py

@@ -0,0 +1,65 @@
+"""Remember successful Git transports without rewriting unrelated configuration."""
+
+import fcntl
+import os
+import tempfile
+from collections.abc import MutableMapping
+from pathlib import Path
+from typing import Any, Literal, cast
+
+import tomlkit
+from tomlkit.exceptions import TOMLKitError
+
+from diffbutler.config.settings import ConfigError
+
+
+def save_git_transport(
+    path: Path,
+    repository: str,
+    transport: Literal["https", "ssh"],
+    *,
+    expected: Literal["auto", "https", "ssh"],
+) -> None:
+    """Merge under a cross-process lock; preserve preferences edited during a fetch."""
+    selected = path.expanduser().resolve()
+    try:
+        selected.parent.mkdir(parents=True, exist_ok=True)
+        with selected.with_name(selected.name + ".lock").open("a") as lock:
+            fcntl.flock(lock, fcntl.LOCK_EX)
+            original = selected.read_text(encoding="utf-8") if selected.exists() else None
+            document = cast(MutableMapping[str, Any], tomlkit.parse(original or ""))
+            if "repos" not in document:
+                document["repos"] = tomlkit.table()
+            repos = document["repos"]
+            if not isinstance(repos, MutableMapping):
+                raise ConfigError("Could not save Git transport: repos must be a table")
+            repos = cast(MutableMapping[str, Any], repos)
+            if repository not in repos:
+                repos[repository] = tomlkit.table()
+            entry = repos[repository]
+            if not isinstance(entry, MutableMapping):
+                raise ConfigError("Could not save Git transport: repository must be a table")
+            entry = cast(MutableMapping[str, Any], entry)
+            current = entry.get("git_transport", "auto")
+            if current != expected or current == transport:
+                return
+            entry["git_transport"] = transport
+            temporary: Path | None = None
+            try:
+                with tempfile.NamedTemporaryFile(
+                    mode="w", encoding="utf-8", dir=selected.parent, delete=False
+                ) as stream:
+                    temporary = Path(stream.name)
+                    stream.write(tomlkit.dumps(document))
+                if original is None:
+                    os.link(temporary, selected)
+                else:
+                    if selected.read_text(encoding="utf-8") != original:
+                        raise ConfigError("Configuration changed while saving Git transport")
+                    temporary.chmod(selected.stat().st_mode & 0o777)
+                    os.replace(temporary, selected)
+            finally:
+                if temporary is not None:
+                    temporary.unlink(missing_ok=True)
+    except OSError, UnicodeError, TOMLKitError:
+        raise ConfigError("Could not save the working Git transport to configuration") from None

diffbutler/core/__init__.py

@@ -0,0 +1 @@
+"""UI-independent application services."""

diffbutler/core/application.py

@@ -0,0 +1,103 @@
+"""Configured shared-core entry points with owned database/forge lifetimes."""
+
+import asyncio
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Literal
+
+from diffbutler.config.settings import Settings, load_settings
+from diffbutler.core.sync import DiffButler, PullRequestRow, SyncReport, list_queue
+from diffbutler.domain.forge import PRPage, PRQuery
+from diffbutler.forges.base import ForgeError
+from diffbutler.forges.registry import open_forge
+from diffbutler.store.dashboard import SQLiteDashboardStore
+from diffbutler.store.database import Database
+from diffbutler.store.queue import SQLiteQueueStore
+
+
+@asynccontextmanager
+async def local_store(path: Path | None) -> AsyncGenerator[tuple[SQLiteQueueStore, Settings]]:
+    settings = await asyncio.to_thread(load_settings, path)
+    database = Database(settings.db.url)
+    try:
+        await database.initialize(auto_migrate=settings.db.auto_migrate)
+        yield SQLiteQueueStore(database), settings
+    finally:
+        await database.close()
+
+
+@asynccontextmanager
+async def remote_service(
+    store: SQLiteQueueStore,
+    settings: Settings,
+    index: int,
+) -> AsyncGenerator[DiffButler]:
+    if not 1 <= index <= len(settings.forges):
+        raise ForgeError("Select a configured forge with --forge (one-based index)")
+    config = settings.forges[index - 1]
+    forge = await open_forge(config)
+    try:
+        preferences = await SQLiteDashboardStore(store.database).preferences()
+        yield DiffButler(
+            store,
+            forge,
+            expected_login=config.login,
+            monitor_repositories=tuple(config.repositories)
+            if preferences.get("monitor_all_prs") == "true"
+            else (),
+        )
+    finally:
+        await forge.close()
+
+
+async def sync_configured(path: Path | None, index: int | None = None) -> tuple[SyncReport, ...]:
+    async with local_store(path) as (store, settings):
+        indexes = [index] if index is not None else list(range(1, len(settings.forges) + 1))
+        if not indexes:
+            raise ForgeError("No forge configured; add a [[forges]] section to configuration")
+        reports: list[SyncReport] = []
+        for selected in indexes:
+            async with remote_service(store, settings, selected) as service:
+                reports.append(await service.sync())
+        from diffbutler.core.managed import ManagedReviews, owned_directories
+
+        managed = ManagedReviews(store.database, settings, await owned_directories(settings))
+        await managed.cleanup()
+        return tuple(reports)
+
+
+async def follow_configured(path: Path | None, index: int, value: str) -> PullRequestRow:
+    async with (
+        local_store(path) as (store, settings),
+        remote_service(store, settings, index) as service,
+    ):
+        return await service.follow_pr(service.forge.ref(value))
+
+
+async def browse_configured(
+    path: Path | None,
+    index: int,
+    query: PRQuery,
+    cursor: str | None,
+) -> PRPage:
+    async with (
+        local_store(path) as (store, settings),
+        remote_service(store, settings, index) as service,
+    ):
+        return await service.browse_prs(query, cursor)
+
+
+async def local_queue(
+    path: Path | None,
+    view: Literal["active", "requested", "following"],
+    login: str | None,
+) -> tuple[PullRequestRow, ...]:
+    async with local_store(path) as (store, settings):
+        return await list_queue(
+            store,
+            view=view,
+            login=login,
+            include_own_prs=settings.ui.include_own_prs,
+            include_assigned_prs=settings.ui.include_assigned_prs,
+        )

diffbutler/core/context.py

@@ -0,0 +1,54 @@
+"""Internal context assembly; does not authorize or launch a reviewer process."""
+
+import asyncio
+
+from diffbutler.domain.forge import PullRequest
+from diffbutler.domain.review import ReviewConflict, RunRecord, RunStatus
+from diffbutler.forges.base import DiffIndex
+from diffbutler.reviewers.base import ReviewBudget, ReviewContext, ReviewSources
+from diffbutler.reviewers.redaction import RedactingSourceReader, redact_and_report
+
+
+async def assemble_context(
+    *,
+    run: RunRecord,
+    pr: PullRequest,
+    sources: ReviewSources,
+    instructions: str,
+    schema_json: str,
+    budget: ReviewBudget,
+) -> ReviewContext:
+    """Assemble local mediated context for an already claimed run.
+
+    The caller must obtain the PR for this task and recheck durable ownership and
+    current policy before execution. This snapshot check is not a worker lease or
+    an isolation boundary. No source is sent to a model by this function.
+    """
+    if run.status != RunStatus.RUNNING or pr.state != "open":
+        raise ReviewConflict("Context requires a running attempt and an open pull request")
+    expected = (run.base_sha, run.head_sha)
+    if (pr.base_sha, pr.head_sha) != expected or (sources.base_sha, sources.head_sha) != expected:
+        raise ReviewConflict("Review context revisions do not match the requested analysis")
+    async with asyncio.timeout(budget.timeout_s):
+        diff = await sources.read_diff()
+    return ReviewContext(
+        pr=pr,
+        session_id=run.session_id,
+        run_id=run.id,
+        comparison_base_sha=sources.comparison_base_sha,
+        # Anchor identity records the requested PR pair; hunks and BASE reads
+        # both come from its resolved merge base, not the target branch tip.
+        diff_index=DiffIndex.parse(diff, base_sha=run.base_sha, head_sha=run.head_sha),
+        diff=redact_and_report(diff.encode("utf-8")).decode("utf-8"),
+        changed_files=sources.changed_files,
+        sources=RedactingSourceReader(sources),
+        instructions=instructions,
+        schema_json=schema_json,
+        budget=budget,
+        limitations=(
+            "Source is available through mediated reads only; no checkout is provided.",
+            "Project tests, builds, and application code were not executed.",
+            "Source credential patterns are masked heuristically; undetected secrets may remain.",
+            *sources.limitations,
+        ),
+    )

diffbutler/core/dashboard.py

@@ -0,0 +1,393 @@
+"""Shared dashboard projections, ordering, history, and explicit state actions."""
+
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Literal, Protocol
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict
+
+from diffbutler.core.application import local_store, remote_service, sync_configured
+from diffbutler.core.managed import resolve_local
+from diffbutler.core.polling import Poller as Poller
+from diffbutler.core.review import ReviewResult, ReviewService
+from diffbutler.core.sync import PullRequestRow, list_queue
+from diffbutler.domain.dashboard import COLUMN_IDS, STATE_LABELS, CycleRecord
+from diffbutler.domain.review import ReviewConflict, ReviewPolicy
+from diffbutler.forges.base import ForgeError
+from diffbutler.store.base import ReviewStore
+from diffbutler.store.dashboard import SQLiteDashboardStore
+from diffbutler.store.review import SQLiteReviewStore
+
+
+class DashboardStore(Protocol):
+    async def cycles(self) -> tuple[CycleRecord, ...]: ...
+    async def choose_state(self, task_id: UUID, *, waiting: bool) -> None: ...
+
+
+class HistoryFilter(BaseModel):
+    repository: str | None = None
+    number: int | None = None
+    reason: str | None = None
+    login: str | None = None
+    since: datetime | None = None
+    until: datetime | None = None
+    completed: bool | None = True
+
+
+class CycleDetail(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    cycle: CycleRecord
+    results: tuple[ReviewResult, ...]
+
+
+class DashboardRow(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    row: PullRequestRow
+    run_status: str = ""
+    reviewed_sha: str = ""
+    findings: int | None = None
+    max_severity: str = ""
+    unverified: int = 0
+    session_name: str = ""
+    attention: float = 0
+
+
+class SortSpec(BaseModel):
+    column: str = "attention"
+    descending: bool = True
+
+
+class DashboardService:
+    def __init__(self, store: DashboardStore, reviews: ReviewStore) -> None:
+        self.store = store
+        self.reviews = ReviewService(reviews, ReviewPolicy(frozenset()))
+
+    async def history(self, filters: HistoryFilter) -> tuple[CycleRecord, ...]:
+        def matches(cycle: CycleRecord) -> bool:
+            pr = cycle.pull_request
+            return (
+                (filters.completed is None or (cycle.completed_at is not None) == filters.completed)
+                and (
+                    filters.repository is None
+                    or filters.repository == f"{pr.ref.namespace}/{pr.ref.repository}"
+                )
+                and (filters.number is None or filters.number == pr.ref.number)
+                and (filters.reason is None or filters.reason == cycle.completion_reason)
+                and (filters.login is None or filters.login.lower() == cycle.account.login.lower())
+                and (
+                    filters.since is None
+                    or (cycle.completed_at is not None and cycle.completed_at >= filters.since)
+                )
+                and (
+                    filters.until is None
+                    or (cycle.completed_at is not None and cycle.completed_at <= filters.until)
+                )
+            )
+
+        return tuple(cycle for cycle in await self.store.cycles() if matches(cycle))
+
+    async def detail(self, task_id: UUID) -> CycleDetail:
+        cycle = next((item for item in await self.store.cycles() if item.task_id == task_id), None)
+        if cycle is None:
+            raise ReviewConflict("History cycle does not exist")
+        results: list[ReviewResult] = []
+        for run in cycle.runs:
+            result = await self.reviews.get_result(run.id)
+            if result is not None:
+                # Normal history never loads raw terminal output into a UI.
+                results.append(result.model_copy(update={"stdout": None, "stderr": None}))
+        return CycleDetail(cycle=cycle, results=tuple(results))
+
+    async def continue_manual_review(self, task_id: UUID) -> None:
+        await self.store.choose_state(task_id, waiting=False)
+
+    async def mark_waiting_for_author(self, task_id: UUID) -> None:
+        await self.store.choose_state(task_id, waiting=True)
+
+
+SEVERITIES = {"question": 0, "nit": 1, "minor": 2, "important": 3, "blocking": 4}
+
+
+def column_value(row: DashboardRow, column: str) -> str | int | float | None:
+    tracked = row.row.tracked
+    pr = tracked.pull_request
+    if column == "attention":
+        return row.attention
+    values: dict[str, str | int | float | None] = {
+        "state": STATE_LABELS.get(tracked.state, tracked.state),
+        "repo": f"{pr.ref.namespace}/{pr.ref.repository}",
+        "number": pr.ref.number,
+        "title": pr.title,
+        "author": pr.author,
+        "ai_status": row.run_status,
+        "findings": row.findings,
+        "max_severity": SEVERITIES.get(row.max_severity, -1),
+        "age": (datetime.now(UTC) - pr.created_at).total_seconds(),
+        "updated": pr.updated_at.timestamp(),
+        "branch": pr.head_ref,
+        "draft": int(pr.is_draft),
+        "reviewers": ", ".join((*pr.requested_users, *pr.requested_teams)),
+        "unverified": row.unverified,
+        "url": pr.url,
+        "additions": pr.additions,
+        "deletions": pr.deletions,
+        "files": pr.files,
+        "labels": ", ".join(pr.labels),
+        "ci": pr.ci,
+    }
+    if column not in values:
+        raise ValueError("Unknown dashboard column")
+    return values[column]
+
+
+def sort_rows(rows: tuple[DashboardRow, ...], sort: SortSpec) -> tuple[DashboardRow, ...]:
+    if sort.column not in COLUMN_IDS:
+        raise ValueError("Unknown dashboard sort column")
+    present = [row for row in rows if column_value(row, sort.column) is not None]
+    missing = [row for row in rows if column_value(row, sort.column) is None]
+
+    def key(row: DashboardRow) -> str | int | float:
+        value = column_value(row, sort.column)
+        assert value is not None
+        return value
+
+    ordered = sorted(present, key=key, reverse=sort.descending) + missing
+    # Keep post-approval changes last regardless of sort column or direction.
+    return tuple(sorted(ordered, key=lambda row: row.row.tracked.state == "DONE_PLUS"))
+
+
+async def dashboard_rows(
+    path: Path | None, view: str = "active", text: str = ""
+) -> tuple[DashboardRow, ...]:
+    async with local_store(path) as (queue, settings):
+        selected: Literal["active", "requested", "following"] = (
+            "requested" if view == "requested" else "following" if view == "following" else "active"
+        )
+        rows = await list_queue(
+            queue,
+            view=selected,
+            include_own_prs=settings.ui.include_own_prs,
+            include_assigned_prs=settings.ui.include_assigned_prs,
+        )
+        store = SQLiteReviewStore(queue.database)
+        reviews = ReviewService(store, ReviewPolicy(frozenset()))
+        result: list[DashboardRow] = []
+        for row in rows:
+            if row.tracked.state == "DONE":
+                continue
+            if view == "triage" and row.tracked.state != "FINDINGS_TRIAGE":
+                continue
+            if view == "posted" and row.tracked.state != "PENDING_AUTHOR_CHANGES":
+                continue
+            pr = row.tracked.pull_request
+            searchable = (
+                f"{pr.ref.namespace}/{pr.ref.repository}#{pr.ref.number} {pr.title} {pr.author}"
+            )
+            if text.lower() not in searchable.lower():
+                continue
+            run = await store.latest_run(row.tracked.task_id) if row.tracked.task_id else None
+            analysis = await reviews.get_result(run.id) if run else None
+            session = await store.get_session(run.session_id) if run else None
+            findings = analysis.document.findings if analysis and analysis.document else None
+            result.append(
+                DashboardRow(
+                    row=row,
+                    run_status=run.status if run else "",
+                    reviewed_sha=run.head_sha if run else "",
+                    session_name=session.display_name if session else "",
+                    findings=len(findings) if findings is not None else None,
+                    max_severity=max(
+                        (finding.severity for finding in findings),
+                        key=lambda value: SEVERITIES[value],
+                        default="",
+                    )
+                    if findings
+                    else "",
+                    unverified=len(analysis.document.orientation.unverified)
+                    if analysis and analysis.document
+                    else 0,
+                )
+            )
+        weights = settings.ui.attention
+
+        def attention(row: DashboardRow) -> float:
+            pr = row.row.tracked.pull_request
+            severity = {
+                "blocking": weights.blocking,
+                "important": weights.important,
+                "minor": 10,
+            }.get(row.max_severity, 0)
+            state = {"FINDINGS_TRIAGE": 50, "PENDING_HUMAN_REVIEW": 20}.get(
+                row.row.tracked.state, 0
+            )
+            if row.run_status == "failed":
+                state = 30
+            age = max(0, (datetime.now(UTC) - pr.created_at).total_seconds() / 86400)
+            size = ((pr.additions or 0) + (pr.deletions or 0)) / 100
+            return (
+                severity
+                + state
+                + age * weights.age_pressure_per_day
+                + size * weights.size_penalty_per_100_lines
+                - (20 if pr.is_draft else 0)
+            )
+
+        return tuple(row.model_copy(update={"attention": attention(row)}) for row in result)
+
+
+async def history_configured(path: Path | None, filters: HistoryFilter) -> tuple[CycleRecord, ...]:
+    async with local_store(path) as (queue, _):
+        return await DashboardService(
+            SQLiteDashboardStore(queue.database), SQLiteReviewStore(queue.database)
+        ).history(filters)
+
+
+async def detail_configured(path: Path | None, task_id: UUID) -> CycleDetail:
+    async with local_store(path) as (queue, _):
+        return await DashboardService(
+            SQLiteDashboardStore(queue.database), SQLiteReviewStore(queue.database)
+        ).detail(task_id)
+
+
+async def state_configured(
+    path: Path | None, value: str, login: str | None, *, waiting: bool
+) -> str:
+    async with local_store(path) as (queue, _):
+        row = await resolve_local(queue, value, login)
+        assert row.tracked.task_id is not None
+        service = DashboardService(
+            SQLiteDashboardStore(queue.database), SQLiteReviewStore(queue.database)
+        )
+        if waiting:
+            await service.mark_waiting_for_author(row.tracked.task_id)
+        else:
+            await service.continue_manual_review(row.tracked.task_id)
+        return row.tracked.pull_request.url
+
+
+async def refresh_configured(path: Path | None, value: str, login: str | None) -> PullRequestRow:
+    """Refresh one PR, preserving a durable pending indication on any failure."""
+    async with local_store(path) as (queue, settings):
+        row = await resolve_local(queue, value, login)
+        assert row.tracked.task_id is not None
+        await SQLiteDashboardStore(queue.database).refresh_pending(row.tracked.task_id)
+        for index, config in enumerate(settings.forges, 1):
+            if f"{config.kind}:{config.base_url.rstrip('/')}" != row.account.forge:
+                continue
+            if config.login and config.login.lower() != row.account.login.lower():
+                continue
+            async with remote_service(queue, settings, index) as service:
+                if (await service.forge.whoami()).login.lower() != row.account.login.lower():
+                    continue
+                service.expected_login = row.account.login
+                return await service.follow_pr(row.tracked.pull_request.ref)
+        raise ForgeError("Refresh pending: no matching configured forge account")
+
+
+async def poll_configured(path: Path | None) -> None:
+    reports = await sync_configured(path)
+    if any(not report.complete for report in reports):
+        raise ForgeError(
+            "Refresh pending: " + "; ".join(w for report in reports for w in report.warnings)
+        )
+
+
+async def preferences_configured(path: Path | None) -> dict[str, str]:
+    async with local_store(path) as (queue, _):
+        return await SQLiteDashboardStore(queue.database).preferences()
+
+
+async def save_sort_configured(path: Path | None, sort: SortSpec) -> None:
+    async with local_store(path) as (queue, _):
+        store = SQLiteDashboardStore(queue.database)
+        await store.set_preference("sort_by", sort.column)
+        await store.set_preference("sort_desc", str(sort.descending).lower())
+
+
+async def cancel_task_configured(path: Path | None, task_id: UUID) -> None:
+    async with local_store(path) as (queue, _):
+        store = SQLiteReviewStore(queue.database)
+        run = await store.latest_run(task_id)
+        if run is not None:
+            await store.cancel_review(run.id)
+
+
+async def diff_configured(path: Path | None, task_id: UUID) -> str:
+    """Explicit source inspection of the saved run's pinned pair; no project execution."""
+    from diffbutler.reviewers.redaction import redact_and_report
+    from diffbutler.sources.git import GitSourceReader
+
+    async with local_store(path) as (queue, settings):
+        detail = await DashboardService(
+            SQLiteDashboardStore(queue.database), SQLiteReviewStore(queue.database)
+        ).detail(task_id)
+        if not detail.cycle.runs:
+            raise ReviewConflict("No reviewed revision is available")
+        pr = detail.cycle.pull_request
+        repo = settings.repos.get(f"{pr.ref.namespace}/{pr.ref.repository}")
+        run = detail.cycle.runs[-1]
+        from diffbutler.core.native import session_directory
+        from diffbutler.reviewers.resources import OwnedDirectories
+
+        store = SQLiteReviewStore(queue.database)
+        resources = await store.session_resources(run.session_id)
+        managed_path: Path | None = None
+        if resources:
+            preset = next((r.preset for r in settings.reviewers if r.id == run.reviewer_id), None)
+            root = await session_directory(
+                store,
+                await OwnedDirectories.reopen(settings.general.workspace_root),
+                run.session_id,
+                preset or "codex",
+            )
+            candidate = root / f"source-{run.id}.git"
+            if candidate.is_dir():
+                managed_path = candidate
+            source_record = root / f"source-{run.id}.json"
+            if source_record.is_file():
+                import json
+
+                managed_path = Path(json.loads(source_record.read_text())["repository"])
+        repository_path = managed_path or (repo.path if repo else None)
+        if repository_path is None:
+            raise ReviewConflict("Pinned source is unavailable or has been removed by cleanup")
+        source = await GitSourceReader.open(
+            repository_path, base_sha=run.base_sha, head_sha=run.head_sha
+        )
+        diff = await source.read_diff()
+        return redact_and_report(diff.encode()).decode()
+
+
+async def log_configured(path: Path | None, task_id: UUID) -> str:
+    async with local_store(path) as (queue, _):
+        store = SQLiteReviewStore(queue.database)
+        run = await store.latest_run(task_id)
+        result = await store.get_result(run.id) if run else None
+        if result is None or result.stdout is None:
+            return "Raw output is unavailable or has been removed by cleanup."
+        return (
+            result.stdout.decode(errors="replace")
+            + "\n"
+            + (result.stderr or b"").decode(errors="replace")
+        )
+
+
+async def pause_configured(path: Path | None, paused: bool) -> None:
+    async with local_store(path) as (queue, _):
+        await SQLiteDashboardStore(queue.database).set_preference(
+            "reviews_paused", str(paused).lower()
+        )
+
+
+async def toggle_monitoring_configured(path: Path | None) -> bool:
+    """Persist discovery scope without starting reviews or contacting a forge."""
+    async with local_store(path) as (queue, settings):
+        store = SQLiteDashboardStore(queue.database)
+        enabled = (await store.preferences()).get("monitor_all_prs") != "true"
+        if enabled and (
+            not settings.forges or any(not forge.repositories for forge in settings.forges)
+        ):
+            raise ForgeError("Set repositories for each forge before monitoring all open PRs")
+        await store.set_preference("monitor_all_prs", str(enabled).lower())
+        return enabled