bugcap 0.2.2__py3-none-any.whl

bugcap/dashboard/static/app.js

@@ -0,0 +1,179 @@
+"use strict";
+(function () {
+  var STATUSES = ["open", "in-progress", "resolved", "closed", "wontfix"];
+  var token = null;
+  var current = null;
+  var $ = function (id) { return document.getElementById(id); };
+
+  function el(tag, text, cls) {
+    var node = document.createElement(tag);
+    if (text !== undefined) node.textContent = text;
+    if (cls) node.className = cls;
+    return node;
+  }
+
+  function getJSON(url) {
+    return fetch(url).then(function (r) {
+      return r.json().then(function (body) { return { ok: r.ok, status: r.status, body: body }; });
+    });
+  }
+
+  function send(method, url, payload) {
+    var go = function () {
+      return fetch(url, {
+        method: method,
+        headers: { "Content-Type": "application/json", "X-Bugcap-Token": token },
+        body: JSON.stringify(payload)
+      }).then(function (r) {
+        return r.json().then(function (body) { return { ok: r.ok, status: r.status, body: body }; });
+      });
+    };
+    if (token) return go();
+    return getJSON("/api/session").then(function (s) { token = s.body.token; return go(); });
+  }
+
+  function fillStatus(select, withAny) {
+    STATUSES.forEach(function (s) { select.appendChild(el("option", s)).value = s; });
+  }
+
+  function query() {
+    var p = new URLSearchParams();
+    if ($("f-q").value) p.set("q", $("f-q").value);
+    if ($("f-status").value) p.set("status", $("f-status").value);
+    if ($("f-repo").value) p.set("repo", $("f-repo").value);
+    $("f-tag").value.split(",").forEach(function (t) { t = t.trim(); if (t) p.append("tag", t); });
+    return p.toString();
+  }
+
+  var timer = null;
+  function refreshList() {
+    getJSON("/api/reports?" + query()).then(function (res) {
+      var ul = $("reports");
+      ul.textContent = "";
+      if (!res.ok) { $("total").textContent = res.body.message || "error"; return; }
+      $("total").textContent = res.body.total + " reports";
+      $("empty").hidden = res.body.items.length > 0;
+      res.body.items.forEach(function (r) {
+        var li = el("li");
+        var title = el("span", "#" + r.id + " " + r.title, "t");
+        li.appendChild(title);
+        li.appendChild(el("span", r.status, "badge"));
+        r.tags.forEach(function (t) { li.appendChild(el("span", t, "badge")); });
+        if (r.media_count) li.appendChild(el("span", r.media_count + " media", "badge"));
+        li.addEventListener("click", function () { openReport(r.id); });
+        ul.appendChild(li);
+      });
+    });
+  }
+
+  function renderNotes(report) {
+    var box = $("d-notes");
+    box.textContent = "";
+    var byId = {};
+    report.media.forEach(function (m) { byId[m.id] = m; });
+    if (!report.notes_segments.length) { box.appendChild(el("span", "(no notes)", "muted")); return; }
+    report.notes_segments.forEach(function (seg) {
+      if (seg.text !== undefined) { box.appendChild(document.createTextNode(seg.text)); return; }
+      var m = byId[seg.ref.media_id];
+      if (!m) { box.appendChild(el("span", seg.ref.token, "ref-missing")); return; }
+      box.appendChild(mediaNode(report, m, seg.ref.token));
+    });
+  }
+
+  function mediaNode(report, m, caption) {
+    var fig = el("figure");
+    if (m.kind === "video") {
+      var v = document.createElement("video");
+      v.controls = true; v.src = m.url; fig.appendChild(v);
+    } else if (m.kind === "frames") {
+      (report.frames[String(m.id)] || []).forEach(function (f) {
+        var img = document.createElement("img");
+        img.src = f.url; img.alt = "frame " + f.frame_no; fig.appendChild(img);
+      });
+    } else {
+      var i = document.createElement("img");
+      i.src = m.url; i.alt = m.label || ("image " + m.index); fig.appendChild(i);
+    }
+    var label = caption || ("#" + m.index);
+    if (m.label) label += " (" + m.label + ")";
+    fig.appendChild(el("figcaption", label + " · " + m.kind + " · " + Math.round(m.size_bytes / 1024) + " KB"));
+    return fig;
+  }
+
+  function renderDetail(report) {
+    current = report;
+    $("d-title").textContent = "#" + report.id + " " + report.title;
+    $("d-meta").textContent = [report.repo, report.created_at].filter(Boolean).join(" · ");
+    $("d-status").value = report.status;
+    var tags = $("d-tags");
+    tags.textContent = "";
+    report.tags.forEach(function (t) {
+      var b = el("span", t + " ×", "badge");
+      b.title = "Remove tag";
+      b.addEventListener("click", function () { changeTags({ remove: [t] }); });
+      tags.appendChild(b);
+    });
+    renderNotes(report);
+    $("notes-edit").value = report.notes_raw;
+    $("notes-msg").textContent = "";
+    var media = $("d-media");
+    media.textContent = "";
+    report.media.forEach(function (m) { media.appendChild(mediaNode(report, m)); });
+    var refs = Object.keys(report.synced_refs || {}).map(function (k) { return k + ": " + report.synced_refs[k]; });
+    var sync = $("d-sync");
+    sync.textContent = "";
+    (report.links || []).forEach(function (l) {
+      var a = el("a", l.label);
+      a.href = l.url; a.target = "_blank"; a.rel = "noopener noreferrer";
+      sync.appendChild(a);
+      sync.appendChild(document.createTextNode(" · "));
+    });
+    sync.appendChild(document.createTextNode(refs.join(" · ")));
+  }
+
+  function openReport(id) {
+    getJSON("/api/reports/" + id).then(function (res) {
+      if (!res.ok) return;
+      renderDetail(res.body);
+      $("list-view").hidden = true;
+      $("detail-view").hidden = false;
+      location.hash = "#" + id;
+    });
+  }
+
+  function changeTags(payload) {
+    send("POST", "/api/reports/" + current.id + "/tags", payload).then(function () { openReport(current.id); });
+  }
+
+  function init() {
+    fillStatus($("d-status"));
+    var f = $("f-status");
+    STATUSES.forEach(function (s) { var o = el("option", s); o.value = s; f.appendChild(o); });
+    ["f-q", "f-status", "f-tag", "f-repo"].forEach(function (id) {
+      $(id).addEventListener("input", function () { clearTimeout(timer); timer = setTimeout(refreshList, 150); });
+    });
+    $("filters").addEventListener("submit", function (e) { e.preventDefault(); refreshList(); });
+    $("back").addEventListener("click", function () {
+      $("detail-view").hidden = true; $("list-view").hidden = false; location.hash = ""; refreshList();
+    });
+    $("d-status").addEventListener("change", function () {
+      send("POST", "/api/reports/" + current.id + "/status", { status: $("d-status").value });
+    });
+    $("tag-form").addEventListener("submit", function (e) {
+      e.preventDefault();
+      var v = $("tag-input").value.trim();
+      if (v) { $("tag-input").value = ""; changeTags({ add: [v] }); }
+    });
+    $("notes-save").addEventListener("click", function () {
+      send("PUT", "/api/reports/" + current.id + "/notes", { notes: $("notes-edit").value }).then(function (res) {
+        if (res.ok) { renderDetail(res.body); return; }
+        var b = res.body;
+        $("notes-msg").textContent = b.message + (b.valid ? " (valid: " + b.valid.join(", ") + ")" : "");
+      });
+    });
+    refreshList();
+    var id = parseInt(location.hash.slice(1), 10);
+    if (id) openReport(id);
+  }
+  init();
+})();

bugcap/dashboard/static/index.html

@@ -0,0 +1,45 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self'; media-src 'self' blob:; connect-src 'self'; object-src 'none'; base-uri 'none'">
+<title>bugcap</title>
+<link rel="stylesheet" href="/static/app.css">
+</head>
+<body>
+<header class="bar"><h1>bugcap</h1><span id="total" class="muted"></span></header>
+<main>
+  <section id="list-view">
+    <form id="filters" class="filters">
+      <input id="f-q" type="search" placeholder="Search title and notes" aria-label="Search">
+      <select id="f-status" aria-label="Status"><option value="">Any status</option></select>
+      <input id="f-tag" type="text" placeholder="Tag (comma separated)" aria-label="Tags">
+      <input id="f-repo" type="text" placeholder="Repo" aria-label="Repo">
+    </form>
+    <ul id="reports" class="reports"></ul>
+    <p id="empty" class="muted" hidden>No reports match.</p>
+  </section>
+  <section id="detail-view" hidden>
+    <button id="back" type="button">&larr; All reports</button>
+    <h2 id="d-title"></h2>
+    <p class="muted" id="d-meta"></p>
+    <div class="row">
+      <label>Status <select id="d-status"></select></label>
+      <span id="d-tags" class="tags"></span>
+      <form id="tag-form" class="inline"><input id="tag-input" placeholder="add tag" aria-label="Add tag"><button>Add</button></form>
+    </div>
+    <h3>Notes</h3>
+    <div id="d-notes" class="notes"></div>
+    <details><summary>Edit notes</summary>
+      <textarea id="notes-edit" rows="6"></textarea>
+      <div><button id="notes-save" type="button">Save notes</button> <span id="notes-msg" class="error" role="alert"></span></div>
+    </details>
+    <h3>Media</h3>
+    <div id="d-media" class="media"></div>
+    <p id="d-sync" class="muted"></p>
+  </section>
+</main>
+<script src="/static/app.js"></script>
+</body>
+</html>

bugcap/drafts.py

@@ -0,0 +1,83 @@
+"""Live-mode drafts: an unsaved capture plus whatever was typed, kept on disk until it is
+saved as a report or discarded. One `<uuid>.png` and one `<uuid>.json` per draft."""
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from .paths import drafts_dir
+
+FIELDS = ("title", "notes", "tags", "status")
+
+
+@dataclass
+class Draft:
+    id: str
+    png_path: Path
+    created_at: str
+    repo: Optional[str]
+    title: str = ""
+    notes: str = ""
+    tags: list = None  # type: ignore[assignment]
+    status: str = "open"
+
+    def fields(self) -> dict:
+        return {"title": self.title, "notes": self.notes, "tags": list(self.tags or []), "status": self.status}
+
+
+def save_draft(repo: Optional[str], png_path, fields: dict) -> Draft:
+    """Move the screenshot into drafts/ and write its sidecar."""
+    draft_id = str(uuid.uuid4())
+    directory = drafts_dir()
+    target = directory / f"{draft_id}.png"
+    shutil.move(str(png_path), target)
+    meta = {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "repo": repo,
+        "title": fields.get("title", ""),
+        "notes": fields.get("notes", ""),
+        "tags": list(fields.get("tags") or []),
+        "status": fields.get("status", "open"),
+    }
+    (directory / f"{draft_id}.json").write_text(json.dumps(meta, indent=2))
+    return Draft(draft_id, target, **meta)
+
+
+def load_draft(draft_id: str) -> Optional[Draft]:
+    directory = drafts_dir()
+    sidecar = directory / f"{draft_id}.json"
+    png = directory / f"{draft_id}.png"
+    try:
+        meta = json.loads(sidecar.read_text())
+        if not png.is_file() or not isinstance(meta, dict):
+            raise ValueError("incomplete draft")
+        return Draft(
+            draft_id, png, meta.get("created_at", ""), meta.get("repo"),
+            str(meta.get("title", "")), str(meta.get("notes", "")),
+            [str(t) for t in meta.get("tags", [])], str(meta.get("status", "open")),
+        )
+    except (OSError, ValueError, TypeError) as exc:
+        print(f"warning: skipping unreadable draft {draft_id}: {exc}", file=sys.stderr)
+        return None
+
+
+def list_drafts(repo: Optional[str]) -> list[Draft]:
+    """Drafts saved for this repo (or without a repo), oldest first."""
+    found = []
+    for sidecar in sorted(drafts_dir().glob("*.json")):
+        draft = load_draft(sidecar.stem)
+        if draft is not None and draft.repo == repo:
+            found.append(draft)
+    return sorted(found, key=lambda d: d.created_at)
+
+
+def delete_draft(draft_id: str) -> None:
+    directory = drafts_dir()
+    for suffix in (".png", ".json"):
+        (directory / f"{draft_id}{suffix}").unlink(missing_ok=True)

bugcap/errors.py

@@ -0,0 +1,30 @@
+"""Errors raised by the shared service layer; each interface maps `code` to its own output."""
+from __future__ import annotations
+
+from typing import Optional
+
+CODES = (
+    "not_found",
+    "invalid_reference",
+    "duplicate_label",
+    "invalid_label",
+    "invalid_title",
+    "invalid_image",
+    "too_large",
+    "timeout",
+    "referenced_image",
+    "invalid_status",
+    "bad_query",
+    "bad_token",
+)
+
+
+class ServiceError(Exception):
+    def __init__(self, code: str, message: str, details: Optional[dict] = None):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.details = details or {}
+
+    def as_dict(self) -> dict:
+        return {"code": self.code, "message": self.message, **self.details}

bugcap/ghcli.py

@@ -0,0 +1,175 @@
+"""Thin wrapper over the GitHub CLI (`gh`). Always argv lists (never shell strings);
+large JSON payloads go to `gh api` via stdin, never argv (Windows ~32k limit)."""
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+from typing import Optional
+
+
+class GhError(RuntimeError):
+    pass
+
+
+def _install_hint() -> str:
+    if sys.platform == "win32":
+        return "winget install GitHub.cli (or https://cli.github.com)"
+    if sys.platform == "darwin":
+        return "brew install gh (or https://cli.github.com)"
+    return "see https://github.com/cli/cli#installation (apt install gh, dnf install gh, ...)"
+
+
+def ensure_ready() -> None:
+    """Raise GhError unless `gh` is installed and authenticated."""
+    if not shutil.which("gh"):
+        raise GhError(f"GitHub CLI (`gh`) not found. Install: {_install_hint()}")
+    result = subprocess.run(
+        ["gh", "auth", "status"], capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        raise GhError("`gh` is not logged in. Run `gh auth login`.")
+
+
+def run_gh(args: list[str], stdin: Optional[str] = None) -> subprocess.CompletedProcess:
+    """Run `gh <args>` capturing text output; `stdin` is fed to the process if given."""
+    return subprocess.run(
+        ["gh", *args], input=stdin, capture_output=True, text=True
+    )
+
+
+def _checked(args: list[str], stdin: Optional[str] = None) -> str:
+    result = run_gh(args, stdin=stdin)
+    if result.returncode != 0:
+        raise GhError((result.stderr or result.stdout or "gh failed").strip())
+    return result.stdout
+
+
+def list_issues(slug: str, labels: Optional[list[str]] = None, limit: int = 30) -> list[dict]:
+    args = [
+        "issue", "list", "--repo", slug, "--state", "open",
+        "--limit", str(limit),
+        "--json", "number,title,body,url,state,labels",
+    ]
+    for label in labels or []:
+        args += ["--label", label]
+    out = _checked(args)
+    return json.loads(out or "[]")
+
+
+def repo_visibility(slug: str) -> str:
+    """Repo visibility ('public'/'private'/'internal'); any failure is treated as 'public'."""
+    result = run_gh(["repo", "view", slug, "--json", "visibility"])
+    if result.returncode != 0:
+        return "public"
+    try:
+        return str(json.loads(result.stdout).get("visibility", "public")).lower()
+    except (ValueError, AttributeError):
+        return "public"
+
+
+def supports_attach() -> bool:
+    """Feature-detect `gh issue create --attach` (present in recent gh releases)."""
+    result = run_gh(["issue", "create", "--help"])
+    return "--attach" in (result.stdout or "")
+
+
+def create_issue(
+    slug: str, title: str, body: str, attach: Optional[str] = None
+) -> str:
+    """Create an issue; return the issue URL printed by gh (parsed from stdout)."""
+    args = ["issue", "create", "--repo", slug, "--title", title, "--body-file", "-"]
+    if attach:
+        args += ["--attach", attach]
+    result = run_gh(args, stdin=body)
+    url = _first_url(result.stdout) or _first_url(result.stderr)
+    if result.returncode != 0 and not url:
+        raise GhError((result.stderr or result.stdout or "gh issue create failed").strip())
+    if not url:
+        raise GhError("could not determine the created issue URL from gh output")
+    return url
+
+
+def comment_issue(slug: str, number: int, body: str) -> str:
+    args = ["issue", "comment", str(number), "--repo", slug, "--body-file", "-"]
+    out = _checked(args, stdin=body)
+    return _first_url(out) or ""
+
+
+def get_contents(slug: str, path: str, ref: Optional[str] = None) -> Optional[dict]:
+    """GET repo contents; None on 404 (missing file)."""
+    endpoint = f"repos/{slug}/contents/{path}"
+    if ref:
+        endpoint += f"?ref={ref}"
+    result = run_gh(["api", endpoint])
+    if result.returncode != 0:
+        return None
+    try:
+        return json.loads(result.stdout)
+    except ValueError:
+        return None
+
+
+def put_contents(
+    slug: str,
+    path: str,
+    content_b64: str,
+    message: str,
+    branch: Optional[str] = None,
+    sha: Optional[str] = None,
+) -> dict:
+    """PUT repo contents (create/update a file). Payload (incl. base64) goes via stdin."""
+    payload: dict = {"message": message, "content": content_b64}
+    if branch:
+        payload["branch"] = branch
+    if sha:
+        payload["sha"] = sha
+    endpoint = f"repos/{slug}/contents/{path}"
+    out = _checked(
+        ["api", "--method", "PUT", endpoint, "--input", "-"],
+        stdin=json.dumps(payload),
+    )
+    return json.loads(out or "{}")
+
+
+def _first_url(text: Optional[str]) -> Optional[str]:
+    for token in (text or "").split():
+        if token.startswith("http://") or token.startswith("https://"):
+            return token.strip()
+    return None
+
+
+class GhUnavailable(RuntimeError):
+    """Cannot verify (no `gh`, not logged in, offline): callers warn and carry on."""
+
+
+def verify_repo(slug: str, branch: Optional[str] = None, need_write: bool = False) -> None:
+    """Check that `slug` exists (and, with `need_write`, that the current login can push) and
+    that `branch` exists. Raises GhError for a definite problem naming the bad value and
+    GhUnavailable when the check itself cannot be done."""
+    try:
+        ensure_ready()
+    except GhError as exc:
+        raise GhUnavailable(str(exc)) from exc
+
+    def fetch(endpoint: str):
+        result = run_gh(["api", endpoint])
+        if result.returncode == 0:
+            try:
+                return json.loads(result.stdout or "{}")
+            except ValueError:
+                return {}
+        text = f"{result.stderr} {result.stdout}"
+        if "404" in text or "Not Found" in text:
+            return None
+        raise GhUnavailable(text.strip() or "gh api failed")
+
+    info = fetch(f"repos/{slug}")
+    if info is None:
+        raise GhError(f"repo {slug!r} does not exist, or your `gh` login cannot see it")
+    permissions = info.get("permissions") if isinstance(info, dict) else None
+    if need_write and isinstance(permissions, dict) and permissions.get("push") is False:
+        raise GhError(f"repo {slug!r} is not writable with the current `gh` login")
+    if branch and fetch(f"repos/{slug}/branches/{branch}") is None:
+        raise GhError(f"branch {branch!r} does not exist in {slug}")