bugpilot 0.1.0__py3-none-any.whl

bugpilot/core/email_notify.py

@@ -0,0 +1,316 @@
+"""Build and send the post-fix notification email.
+
+The email is assembled entirely from local bugpilot artifacts (fix_report.md
+and issue.json) and sent over SMTP using credentials supplied through the
+environment. bugpilot never hardcodes SMTP secrets and never commits, pushes, or
+updates Jira as part of sending this notification.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import smtplib
+import ssl
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from email.generator import BytesGenerator
+from email.message import EmailMessage
+from email.utils import formataddr, parseaddr
+from pathlib import Path
+from urllib.parse import urlencode
+
+from .config import EmailConfig, GraphConfig, issue_dir, load_config
+from .fix_report import read_fix_report
+from .issue import read_issue_quietly
+from .jira import JiraSiteError, normalize_jira_site, sanitize_comment_text
+from .models import SOURCE_MANUAL
+
+GRAPH_TOKEN_URL = "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"
+GRAPH_SENDMAIL_URL = "https://graph.microsoft.com/v1.0/users/{sender}/sendMail"
+GRAPH_SCOPE = "https://graph.microsoft.com/.default"
+
+MAX_SECTION_CHARS = 4000
+MAX_BODY_CHARS = 60000
+_NOT_AVAILABLE = "Not available in local artifacts."
+
+
+@dataclass
+class EmailDraft:
+    issue_key: str
+    subject: str
+    body: str
+
+
+@dataclass
+class EmailSendResult:
+    issue_key: str
+    sent: bool
+    recipients: tuple[str, ...]
+    skipped_reason: str | None = None
+
+
+class EmailSendError(Exception):
+    """Raised when an SMTP send fails. The message never contains credentials."""
+
+
+def build_email_draft(repo_root: Path, issue_key: str) -> EmailDraft:
+    report = read_fix_report(repo_root, issue_key)
+
+    # The title and the original problem come from the normalized issue, which a
+    # Jira work item and a hand-written one share. Without them the notification
+    # says "not available" for the one thing the reader most needs.
+    issue = read_issue_quietly(repo_root, issue_key)
+    is_manual = issue is not None and issue.source == SOURCE_MANUAL
+
+    summary_line = (issue.title if issue else "") or (report.summary if report else "")
+    summary_line = _first_meaningful_line(summary_line)
+
+    original_problem = (issue.description if issue else "") or _NOT_AVAILABLE
+    root_cause = (report.analysis if report else "") or _NOT_AVAILABLE
+    changes = (report.changes if report else "") or _NOT_AVAILABLE
+    test_summary = (report.tests if report else "") or _NOT_AVAILABLE
+
+    subject = f"[bugpilot] {issue_key} fix ready to commit"
+    if summary_line:
+        subject = f"{subject}: {summary_line[:80]}"
+
+    link_line = "" if is_manual else _jira_link(repo_root, issue_key)
+    item_heading = "Work Item" if is_manual else "Jira Item"
+    body = (
+        "bugpilot bug fix notification\n"
+        "===========================\n\n"
+        "Automated notification generated at the commit decision point.\n"
+        "Review before committing. bugpilot did NOT commit, push, merge, open a PR,\n"
+        "or update Jira.\n\n"
+        f"## {item_heading}\n"
+        f"{issue_key}" + (f" — {summary_line}" if summary_line else "") + "\n"
+        + (f"{link_line}\n" if link_line else "")
+        + "\n"
+        "## Original Problem\n"
+        f"{_cap(original_problem)}\n\n"
+        "## Bug Cause / Root Cause\n"
+        f"{_cap(root_cause)}\n\n"
+        "## Changes Made\n"
+        f"{_cap(changes)}\n\n"
+        "## Tests\n"
+        f"{_cap(test_summary)}\n\n"
+        "--\n"
+        f"Generated by bugpilot from local .ai/{issue_key}/ artifacts.\n"
+    )
+    body = _cap(sanitize_comment_text(body), MAX_BODY_CHARS)
+    return EmailDraft(issue_key=issue_key, subject=subject, body=body)
+
+
+def send_notification(config: EmailConfig, draft: EmailDraft) -> EmailSendResult:
+    if not config.is_configured:
+        missing = ", ".join(config.missing_fields())
+        return EmailSendResult(
+            issue_key=draft.issue_key,
+            sent=False,
+            recipients=config.recipients,
+            skipped_reason=f"Email not configured. Missing: {missing}.",
+        )
+
+    invalid = [addr for addr in config.recipients if not _looks_like_email(addr)]
+    if invalid or not _looks_like_email(config.sender or ""):
+        bad = ", ".join(invalid or [config.sender or "(empty)"])
+        raise EmailSendError(f"Invalid email address configured: {bad}")
+
+    message = _build_message(config, draft)
+    try:
+        _deliver(config, message)
+    except (smtplib.SMTPException, OSError) as exc:
+        # Surface the error class/reason, never the credentials.
+        raise EmailSendError(f"SMTP send failed: {type(exc).__name__}: {exc}") from exc
+
+    return EmailSendResult(
+        issue_key=draft.issue_key,
+        sent=True,
+        recipients=config.recipients,
+    )
+
+
+def render_eml(draft: EmailDraft, sender: str | None = None, recipients: tuple[str, ...] = ()) -> bytes:
+    """Render the draft as a standalone RFC 822 .eml file.
+
+    Works without SMTP configuration: From/To headers are filled in only when
+    available so the file can be opened in Outlook (which sends over its own
+    modern-auth channel, sidestepping SMTP entirely).
+    """
+    message = _message(draft, sender, recipients)
+    buffer = io.BytesIO()
+    BytesGenerator(buffer, policy=message.policy).flatten(message)
+    return buffer.getvalue()
+
+
+def send_via_graph(
+    graph_config: GraphConfig,
+    draft: EmailDraft,
+    sender: str | None,
+    recipients: tuple[str, ...],
+) -> EmailSendResult:
+    """Send the notification through Microsoft Graph (client-credentials flow).
+
+    Uses HTTPS only, so it works when the tenant disables SMTP client auth and
+    when outbound port 25 is blocked. Requires an app registration with the
+    application permission Mail.Send (admin-consented).
+    """
+    if not graph_config.is_configured or not sender or not recipients:
+        missing = ", ".join(graph_config.missing_fields())
+        if not sender:
+            missing = (missing + ", BUGPILOT_EMAIL_FROM").lstrip(", ")
+        if not recipients:
+            missing = (missing + ", BUGPILOT_EMAIL_TO").lstrip(", ")
+        return EmailSendResult(
+            issue_key=draft.issue_key,
+            sent=False,
+            recipients=recipients,
+            skipped_reason=f"Graph email not configured. Missing: {missing}.",
+        )
+
+    invalid = [addr for addr in recipients if not _looks_like_email(addr)]
+    if invalid or not _looks_like_email(sender):
+        bad = ", ".join(invalid or [sender])
+        raise EmailSendError(f"Invalid email address configured: {bad}")
+
+    token = _graph_token(graph_config)
+    _graph_send_mail(token, sender, recipients, draft)
+    return EmailSendResult(issue_key=draft.issue_key, sent=True, recipients=recipients)
+
+
+def _graph_token(graph_config: GraphConfig) -> str:
+    data = urlencode(
+        {
+            "client_id": graph_config.client_id,
+            "client_secret": graph_config.client_secret,
+            "scope": GRAPH_SCOPE,
+            "grant_type": "client_credentials",
+        }
+    ).encode("utf-8")
+    request = urllib.request.Request(
+        GRAPH_TOKEN_URL.format(tenant=graph_config.tenant_id),
+        data=data,
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        # Do not echo the request body (it carries the client secret).
+        raise EmailSendError(f"Graph token request failed: HTTP {exc.code}") from exc
+    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        raise EmailSendError(f"Graph token request failed: {type(exc).__name__}: {exc}") from exc
+    token = payload.get("access_token") if isinstance(payload, dict) else None
+    if not token:
+        raise EmailSendError("Graph token response did not contain an access token.")
+    return str(token)
+
+
+def _graph_send_mail(token: str, sender: str, recipients: tuple[str, ...], draft: EmailDraft) -> None:
+    body = json.dumps(
+        {
+            "message": {
+                "subject": draft.subject,
+                "body": {"contentType": "Text", "content": draft.body},
+                "toRecipients": [{"emailAddress": {"address": addr}} for addr in recipients],
+            },
+            "saveToSentItems": True,
+        }
+    ).encode("utf-8")
+    request = urllib.request.Request(
+        GRAPH_SENDMAIL_URL.format(sender=sender),
+        data=body,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            response.read()
+    except urllib.error.HTTPError as exc:
+        detail = _graph_error_detail(exc)
+        raise EmailSendError(f"Graph sendMail failed: HTTP {exc.code}{detail}") from exc
+    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        raise EmailSendError(f"Graph sendMail failed: {type(exc).__name__}: {exc}") from exc
+
+
+def _graph_error_detail(exc: urllib.error.HTTPError) -> str:
+    try:
+        payload = json.loads(exc.read().decode("utf-8"))
+        code = payload.get("error", {}).get("code")
+        return f" ({code})" if code else ""
+    except Exception:
+        return ""
+
+
+def _build_message(config: EmailConfig, draft: EmailDraft) -> EmailMessage:
+    return _message(draft, config.sender, config.recipients)
+
+
+def _message(draft: EmailDraft, sender: str | None, recipients: tuple[str, ...]) -> EmailMessage:
+    message = EmailMessage()
+    message["Subject"] = draft.subject
+    if sender:
+        message["From"] = formataddr(("bugpilot", sender))
+    if recipients:
+        message["To"] = ", ".join(recipients)
+    message.set_content(draft.body)
+    return message
+
+
+def _deliver(config: EmailConfig, message: EmailMessage) -> None:
+    host = config.host or ""
+    if config.use_ssl:
+        context = ssl.create_default_context()
+        with smtplib.SMTP_SSL(host, config.port, timeout=30, context=context) as server:
+            _authenticate_and_send(server, config, message)
+        return
+    with smtplib.SMTP(host, config.port, timeout=30) as server:
+        if config.use_starttls:
+            server.starttls(context=ssl.create_default_context())
+        _authenticate_and_send(server, config, message)
+
+
+def _authenticate_and_send(server: smtplib.SMTP, config: EmailConfig, message: EmailMessage) -> None:
+    if config.uses_auth:
+        server.login(config.username or "", config.password or "")
+    server.send_message(message)
+
+
+def _jira_link(repo_root: Path, issue_key: str) -> str:
+    base_url = load_config(repo_root).jira_base_url
+    if not base_url:
+        return ""
+    # The site Jira requests accept, or no link: an http:// or credential-bearing
+    # value never reaches a recipient's mailbox.
+    try:
+        site = normalize_jira_site(base_url)
+    except JiraSiteError:
+        return ""
+    return f"Link: {site}/browse/{issue_key}"
+
+
+def _first_meaningful_line(text: str) -> str:
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped and stripped != "TBD":
+            return stripped
+    return ""
+
+
+def _cap(text: str, limit: int = MAX_SECTION_CHARS) -> str:
+    text = text.strip() or _NOT_AVAILABLE
+    if len(text) <= limit:
+        return text
+    return text[:limit].rstrip() + "\n\n[truncated by bugpilot]"
+
+
+def _looks_like_email(address: str) -> bool:
+    name, addr = parseaddr(address)
+    del name
+    return "@" in addr and "." in addr.split("@")[-1] and " " not in addr

bugpilot/core/errors.py

@@ -0,0 +1,105 @@
+"""Stable error codes shared by every entry point.
+
+The codes are the machine-facing half of a failure; the human message is the
+other half and may be reworded freely. A VS Code extension branches on
+``error.code`` and never parses the message — see ``docs/adapter_design.md``
+section 5.1.
+
+A code says *what went wrong*. The command being run is reported separately, so
+the same JIRA_AUTH_FAILED covers a failed fetch and a failed comment post rather
+than needing one code per operation.
+
+Adding a code is a contract change: append, never rename or repurpose.
+"""
+
+from __future__ import annotations
+
+# --- Jira -------------------------------------------------------------------
+
+JIRA_NOT_CONFIGURED = "JIRA_NOT_CONFIGURED"
+JIRA_AUTH_FAILED = "JIRA_AUTH_FAILED"
+JIRA_ISSUE_NOT_FOUND = "JIRA_ISSUE_NOT_FOUND"
+JIRA_RATE_LIMITED = "JIRA_RATE_LIMITED"
+JIRA_TIMEOUT = "JIRA_TIMEOUT"
+JIRA_NETWORK_ERROR = "JIRA_NETWORK_ERROR"
+JIRA_INVALID_RESPONSE = "JIRA_INVALID_RESPONSE"
+JIRA_ERROR = "JIRA_ERROR"
+# The configured Jira site is not an https:// address BugPilot will send
+# credentials to.
+JIRA_INVALID_SITE = "JIRA_INVALID_SITE"
+# Jira redirected to another origin, and the credentials were not sent there.
+JIRA_REDIRECT_REFUSED = "JIRA_REDIRECT_REFUSED"
+
+# --- source-mode gates (design section 5.1) ---------------------------------
+
+# The command only makes sense for a Jira work item (fetch, jira-validate, parse).
+JIRA_ONLY_COMMAND = "JIRA_ONLY_COMMAND"
+# There is no external issue to write back to: a manual work item has no source_ref.
+NO_JIRA_TARGET = "NO_JIRA_TARGET"
+
+# --- local state ------------------------------------------------------------
+
+WORK_ITEM_NOT_FOUND = "WORK_ITEM_NOT_FOUND"
+ARTIFACT_NOT_FOUND = "ARTIFACT_NOT_FOUND"
+MISSING_RESULTS = "MISSING_RESULTS"
+INVALID_INPUT = "INVALID_INPUT"
+# The artifact a command would write is already there, and the command keeps it
+# unless asked to replace it (record-review or record-verification without
+# --replace).
+ARTIFACT_EXISTS = "ARTIFACT_EXISTS"
+
+# --- other ------------------------------------------------------------------
+
+EMAIL_SEND_FAILED = "EMAIL_SEND_FAILED"
+INTERNAL_ERROR = "INTERNAL_ERROR"
+
+# jira.ERROR_MESSAGES keys -> codes. That vocabulary already exists and is
+# stable, so the mapping is a rename rather than a second classification.
+_JIRA_ERROR_TYPES: dict[str, str] = {
+    "missing_env": JIRA_NOT_CONFIGURED,
+    "auth_or_permission": JIRA_AUTH_FAILED,
+    "not_found": JIRA_ISSUE_NOT_FOUND,
+    "rate_limited": JIRA_RATE_LIMITED,
+    "timeout": JIRA_TIMEOUT,
+    "network_error": JIRA_NETWORK_ERROR,
+    "invalid_response": JIRA_INVALID_RESPONSE,
+    "unknown_error": JIRA_ERROR,
+    "invalid_site": JIRA_INVALID_SITE,
+    "redirect_refused": JIRA_REDIRECT_REFUSED,
+}
+
+
+def code_for_jira_error_type(error_type: str | None) -> str:
+    """Map a ``jira.ERROR_MESSAGES`` key to its stable code."""
+    return _JIRA_ERROR_TYPES.get(error_type or "", JIRA_ERROR)
+
+
+def error_code_for(exc: BaseException) -> str:
+    """Classify an exception for the machine-facing envelope.
+
+    Imports are local so this module stays a leaf: every adapter needs the code
+    vocabulary, and a top-level import of ``jira`` would drag its network stack
+    into anything that only wants to name a code.
+    """
+    from .email_notify import EmailSendError
+    from .jira import JiraCommentPostError, JiraFetchError
+
+    if isinstance(exc, JiraFetchError):
+        return code_for_jira_error_type(getattr(exc.result, "error_type", None))
+    if isinstance(exc, JiraCommentPostError):
+        return code_for_jira_error_type(getattr(exc, "error_type", None))
+    if isinstance(exc, EmailSendError):
+        return EMAIL_SEND_FAILED
+    from .run import RunArtifactError
+
+    if isinstance(exc, FileNotFoundError):
+        return ARTIFACT_NOT_FOUND
+    if isinstance(exc, FileExistsError):
+        return ARTIFACT_EXISTS
+    # Before the ValueError arm it subclasses: an unusable run.json is a state
+    # problem the caller fixes by re-preparing, not a bad argument.
+    if isinstance(exc, RunArtifactError):
+        return ARTIFACT_NOT_FOUND
+    if isinstance(exc, ValueError):
+        return INVALID_INPUT
+    return INTERNAL_ERROR

bugpilot/core/executables.py

@@ -0,0 +1,87 @@
+"""Finding external programs without trusting the current directory.
+
+BugPilot runs in the repository it is preparing: that directory is the process's
+current directory, and every ``git`` and ``rg`` call passes it as ``cwd``. On
+Windows a bare program name is looked up in the current directory *before*
+``PATH`` — by ``CreateProcess`` and by ``shutil.which`` alike, unless the
+``NoDefaultCurrentDirectoryInExePath`` variable happens to be set — so a
+``git.exe`` committed to a repository would run instead of Git the moment
+BugPilot touched it.
+
+So no program is started by its bare name. :func:`find_executable` resolves a
+name to an absolute path using only the absolute entries of ``PATH``, in order,
+with ``PATHEXT`` on Windows; it never consults the current directory, and it
+skips empty, ``.`` and other relative ``PATH`` entries, which mean the same
+thing. Callers start the absolute path it returns.
+
+The VS Code extension applies the same policy to the programs it starts
+(``extension/src/executablePath.ts``).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+_DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD"
+
+
+def _is_windows() -> bool:
+    return sys.platform == "win32"
+
+
+def _runnable(candidate: Path) -> bool:
+    try:
+        if not candidate.is_file():
+            return False
+    except OSError:
+        return False
+    return True if _is_windows() else os.access(candidate, os.X_OK)
+
+
+def find_executable(name: str, path: str | None = None) -> str | None:
+    """The absolute path ``name`` resolves to, or ``None``.
+
+    - An absolute path is returned as it is, if it names a runnable file.
+    - A relative path with a directory part (``tools/rg``) is refused: it would
+      resolve against the repository.
+    - A bare name is searched in the absolute entries of ``path`` (default: the
+      ``PATH`` environment variable), never in the current directory.
+    """
+    if not name:
+        return None
+    given = Path(name)
+    if given.is_absolute():
+        return str(given) if _runnable(given) else None
+    if os.sep in name or (os.altsep and os.altsep in name) or "/" in name:
+        return None
+    search = os.environ.get("PATH", "") if path is None else path
+    if _is_windows():
+        extensions = [ext for ext in (os.environ.get("PATHEXT") or _DEFAULT_PATHEXT).split(";") if ext]
+        has_extension = any(name.lower().endswith(ext.lower()) for ext in extensions)
+        names = [name] if has_extension else [name + ext for ext in extensions]
+    else:
+        names = [name]
+    for entry in search.split(os.pathsep):
+        entry = entry.strip().strip('"')
+        if not entry or not os.path.isabs(entry):
+            continue
+        for candidate_name in names:
+            candidate = Path(entry) / candidate_name
+            if _runnable(candidate):
+                return str(candidate)
+    return None
+
+
+def child_environment(base: dict[str, str] | None = None) -> dict[str, str]:
+    """An environment for a child that starts programs of its own.
+
+    On Windows, ``NoDefaultCurrentDirectoryInExePath`` makes ``cmd.exe`` and
+    ``CreateProcess`` callers inside the child skip the current directory too —
+    an npm ``claude.cmd`` shim, for one, looks up a bare ``node``.
+    """
+    env = dict(os.environ if base is None else base)
+    if _is_windows():
+        env["NoDefaultCurrentDirectoryInExePath"] = "1"
+    return env