bugcap 0.3.0__tar.gz → 0.5.0__tar.gz

{bugcap-0.3.0/src/bugcap.egg-info → bugcap-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bugcap
-Version: 0.3.0
+Version: 0.5.0
 Summary: Local-first, agent-readable bug capture: annotated screenshots + notes, stored locally, synced to trackers on your own schedule.
 Author: Konrad Tagnon Amen ALAHASSA
 License: MIT
@@ -63,7 +63,7 @@ bugcap keeps the whole loop in one place:
 | 🔁 **Sync when ready** | Push to a GitHub issue with the usual inline image, plus a plain copy agents can read. |
 | 🎞️ **Record what happens** | Short screen recordings as animated GIF, video or keyframes, with size caps. |
 | 🖥️ **Triage in a browser** | A local dashboard on `127.0.0.1` to browse, filter and set statuses. |
-| 🪟 **Live mode** | An always-on-top window for reporting many bugs in a row. |
+| 🪟 **Live mode** | An always-on-top window (top-right) to capture or record, stage several items, then file a new bug, add to an existing one, or log a note-only bug. |
 
 ## Quick start
 

{bugcap-0.3.0 → bugcap-0.5.0}/README.md

@@ -47,7 +47,7 @@ bugcap keeps the whole loop in one place:
 | 🔁 **Sync when ready** | Push to a GitHub issue with the usual inline image, plus a plain copy agents can read. |
 | 🎞️ **Record what happens** | Short screen recordings as animated GIF, video or keyframes, with size caps. |
 | 🖥️ **Triage in a browser** | A local dashboard on `127.0.0.1` to browse, filter and set statuses. |
-| 🪟 **Live mode** | An always-on-top window for reporting many bugs in a row. |
+| 🪟 **Live mode** | An always-on-top window (top-right) to capture or record, stage several items, then file a new bug, add to an existing one, or log a note-only bug. |
 
 ## Quick start
 

{bugcap-0.3.0 → bugcap-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bugcap"
-version = "0.3.0"
+version = "0.5.0"
 description = "Local-first, agent-readable bug capture: annotated screenshots + notes, stored locally, synced to trackers on your own schedule."
 readme = "README.md"
 requires-python = ">=3.10"

bugcap-0.5.0/src/bugcap/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

{bugcap-0.3.0 → bugcap-0.5.0}/src/bugcap/cli.py

@@ -152,12 +152,8 @@ def cmd_list(args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_show(args: argparse.Namespace) -> int:
-    with Store() as store:
-        report = resolve_report(store, args.id)
-        if report is None:
-            return 1
-
+def print_report(report) -> None:
+    """The multi-line details of one report, as `bugcap show` prints them."""
     print(f"#{report.id}  {report.title}")
     print(f"  created_at: {report.created_at}")
     print(f"  status:     {report.status}")
@@ -181,6 +177,15 @@ def cmd_show(args: argparse.Namespace) -> int:
             print(f"    - {tracker}: {ref}")
     else:
         print("    (not synced to any tracker yet)")
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    with Store() as store:
+        report = resolve_report(store, args.id)
+        if report is None:
+            return 1
+
+    print_report(report)
     return 0
 
 
@@ -574,6 +579,8 @@ def cmd_attach(args: argparse.Namespace) -> int:
         print(f"Attached {shot_path} to report #{args.id}")
     elif note and added:
         print(f"Added note to report #{args.id}")
+    print()
+    print_report(current)
     return 1 if rejected or (note and not added) else 0
 
 

bugcap-0.5.0/src/bugcap/drafts.py

@@ -0,0 +1,134 @@
+"""Live-mode drafts: unsaved staged media (any number of images / recordings, or none) plus
+whatever was typed, kept on disk until it is saved as a report or discarded. One
+`<uuid>.json` sidecar per draft; its media files sit beside it as `<uuid>-*`. A draft made by
+an older version is just `<uuid>.png` + `<uuid>.json` and still loads."""
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import uuid
+from dataclasses import dataclass, field
+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
+    created_at: str
+    repo: Optional[str]
+    title: str = ""
+    notes: str = ""
+    tags: list = None  # type: ignore[assignment]
+    status: str = "open"
+    # [{"kind", "path" (absolute or None), "mime", "size_bytes", "frames": [(path, size)]}]
+    items: list = field(default_factory=list)
+
+    def fields(self) -> dict:
+        return {"title": self.title, "notes": self.notes, "tags": list(self.tags or []), "status": self.status}
+
+    @property
+    def png_path(self) -> Optional[Path]:
+        """The first stored file (the screenshot of a single-image draft), if any."""
+        for item in self.items:
+            if item["path"]:
+                return Path(item["path"])
+        return None
+
+
+def _move(source, target: Path) -> Path:
+    shutil.move(str(source), target)
+    return target
+
+
+def save_draft(repo: Optional[str], png_path, fields: dict, items: Optional[list] = None) -> Draft:
+    """Move the media into drafts/ and write the sidecar. `items` are dicts shaped like
+    `Draft.items`; for a plain screenshot pass `png_path` instead."""
+    if items is None:
+        items = [{"kind": "image", "path": str(png_path), "mime": "image/png", "size_bytes": 0, "frames": []}] if png_path else []
+    draft_id = str(uuid.uuid4())
+    directory = drafts_dir()
+    listed = []
+    for n, item in enumerate(items, start=1):
+        path = item.get("path")
+        new_path = _move(path, directory / f"{draft_id}-{n}{Path(path).suffix}") if path else None
+        frames = []
+        for m, (frame_path, size) in enumerate(item.get("frames") or [], start=1):
+            frames.append([_move(frame_path, directory / f"{draft_id}-{n}-f{m:03d}.png").name, size])
+        listed.append({
+            "kind": item["kind"], "file": new_path.name if new_path else None,
+            "mime": item.get("mime", "image/png"), "size_bytes": item.get("size_bytes", 0), "frames": frames,
+        })
+    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"),
+        "media": listed,
+    }
+    (directory / f"{draft_id}.json").write_text(json.dumps(meta, indent=2))
+    return load_draft(draft_id)  # type: ignore[return-value]
+
+
+def _items_from_meta(directory: Path, draft_id: str, meta: dict) -> list:
+    if "media" not in meta:  # legacy: one screenshot
+        png = directory / f"{draft_id}.png"
+        if not png.is_file():
+            raise ValueError("incomplete draft")
+        return [{"kind": "image", "path": str(png), "mime": "image/png", "size_bytes": png.stat().st_size, "frames": []}]
+    items = []
+    for entry in meta["media"]:
+        path = directory / entry["file"] if entry.get("file") else None
+        frames = [(str(directory / name), int(size)) for name, size in entry.get("frames", [])]
+        files = ([path] if path else []) + [Path(p) for p, _ in frames]
+        if not files or not all(f.is_file() for f in files):
+            raise ValueError("incomplete draft")
+        items.append({
+            "kind": str(entry["kind"]), "path": str(path) if path else None, "mime": str(entry.get("mime", "")),
+            "size_bytes": int(entry.get("size_bytes", 0)), "frames": frames,
+        })
+    return items
+
+
+def load_draft(draft_id: str) -> Optional[Draft]:
+    directory = drafts_dir()
+    sidecar = directory / f"{draft_id}.json"
+    try:
+        meta = json.loads(sidecar.read_text())
+        if not isinstance(meta, dict):
+            raise ValueError("incomplete draft")
+        return Draft(
+            draft_id, 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")),
+            _items_from_meta(directory, draft_id, meta),
+        )
+    except (OSError, ValueError, TypeError, KeyError) 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()
+    (directory / f"{draft_id}.json").unlink(missing_ok=True)
+    (directory / f"{draft_id}.png").unlink(missing_ok=True)
+    for leftover in directory.glob(f"{draft_id}-*"):
+        leftover.unlink(missing_ok=True)

{bugcap-0.3.0 → bugcap-0.5.0}/src/bugcap/ingest.py

@@ -1,11 +1,13 @@
 """Bring existing images into the store: local paths, globs and http(s) URLs.
 
 Every input is validated by its magic bytes (never its extension or Content-Type), copied
-into the images directory under a fresh name (the original path is not kept), and written
-atomically. Network access is limited to plain http(s) GETs with no credentials."""
+into the images directory under a name derived from its content (the original path is not
+kept) and written atomically. The same image is therefore stored once, however many reports
+use it. Network access is limited to plain http(s) GETs with no credentials."""
 from __future__ import annotations
 
 import glob
+import hashlib
 import os
 import socket
 import urllib.error
@@ -32,6 +34,7 @@ class StoredFile:
     mime: str
     size_bytes: int
     source: str
+    reused: bool = False  # the content was already in the store; no new file was written
 
 
 @dataclass
@@ -70,10 +73,16 @@ def sniff_image(data: bytes) -> str:
     raise ServiceError("invalid_image", "not an image (PNG, JPEG, GIF or WebP expected)")
 
 
+def content_name(data: bytes, mime: str) -> str:
+    return f"{hashlib.sha256(data).hexdigest()}{_EXT[mime]}"
+
+
 def _store(data: bytes, source: str) -> StoredFile:
     mime = sniff_image(data)
-    dest = images_dir() / f"{uuid.uuid4()}{_EXT[mime]}"
-    tmp = dest.with_name(dest.name + ".part")
+    dest = images_dir() / content_name(data, mime)
+    if dest.is_file() and dest.stat().st_size == len(data):
+        return StoredFile(to_data_relative(dest), dest, mime, len(data), source, reused=True)
+    tmp = dest.with_name(f"{dest.name}.{uuid.uuid4().hex}.part")
     try:
         tmp.write_bytes(data)
         os.replace(tmp, dest)
@@ -82,6 +91,29 @@ def _store(data: bytes, source: str) -> StoredFile:
     return StoredFile(to_data_relative(dest), dest, mime, len(data), source)
 
 
+def adopt(path) -> Path:
+    """Give a screenshot the capture tool already saved in the store its content-derived
+    name. If the same image is stored already, the new copy is dropped and the existing
+    path returned. Anything that is not a recognisable image, or sits outside the store, is
+    left where it is."""
+    path = Path(path)
+    if path.parent != images_dir():
+        return path
+    try:
+        data = path.read_bytes()
+        mime = sniff_image(data)
+    except (OSError, ServiceError):
+        return path
+    dest = images_dir() / content_name(data, mime)
+    if dest == path:
+        return path
+    if dest.is_file() and dest.stat().st_size == len(data):
+        path.unlink(missing_ok=True)
+        return dest
+    os.replace(path, dest)
+    return dest
+
+
 def import_local(path: Path) -> StoredFile:
     path = Path(path).expanduser()
     if path.is_dir():