sin-code-bundle 0.9.2__py3-none-any.whl

sin_code_bundle/safety.py

@@ -0,0 +1,52 @@
+"""Hardened subprocess + input-sanitization helpers shared by all subsystems."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Optional, Sequence
+
+DEFAULT_TIMEOUT = 600  # seconds — never run unbounded
+
+
+class SafetyError(RuntimeError):
+    """Raised when a safety invariant is violated (timeout, unsafe cmd shape, …)."""
+
+
+def run_checked(
+    cmd: Sequence[str],
+    cwd: Optional[Path] = None,
+    timeout: int = DEFAULT_TIMEOUT,
+    allow_shell: bool = False,
+) -> subprocess.CompletedProcess:
+    """Run a subprocess with a mandatory timeout and no shell by default."""
+    if not allow_shell and not isinstance(cmd, (list, tuple)):
+        raise SafetyError("cmd must be a list/tuple unless allow_shell=True")
+    try:
+        return subprocess.run(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            shell=allow_shell,
+            timeout=timeout,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise SafetyError(f"command timed out after {timeout}s: {cmd}") from exc
+
+
+def sanitize_prompt(
+    text: str, max_len: int = 8000
+) -> str:  # 8000 chars ≈ 2K tokens; fits LLM context without flooding
+    """Neutralize obvious prompt-injection markers in untrusted task text."""
+    if len(text) > max_len:
+        text = text[:max_len] + "\n...[truncated]"
+    safe_lines = []
+    for line in text.splitlines():
+        low = line.strip().lower()
+        if low.startswith(("system:", "developer:", "ignore previous", "you are now")):
+            safe_lines.append("[redacted suspicious instruction]")
+        else:
+            safe_lines.append(line)
+    return "\n".join(safe_lines)

sin_code_bundle/session_warmup.py

@@ -0,0 +1,247 @@
+"""Purpose: One-call session context primer.
+
+Docs: session_warmup.doc.md
+
+Returns a snapshot of the current repository: branch, git state, CoDocs
+coverage, ceo-audit grade (cached), top risks, and a session-level
+recommendation ("ready to code" vs "fix first"). Designed to be the first
+call an agent makes at the start of a session.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Hard-coded fallback for the dev-machine layout (AGENTS.md).
+_CEO_AUDIT_FALLBACK = "/Users/jeremy/.local/bin/sin"
+_ROLLBACK_FALLBACK = "/Users/jeremy/Library/Python/3.14/bin/sin-honcho-rollback"
+
+
+def _human_age(seconds: int) -> str:
+    """Format a duration in seconds as a short human-readable string.
+
+    Examples:
+        >>> _human_age(45)
+        '45s'
+        >>> _human_age(3700)
+        '1h 1m'
+        >>> _human_age(90000)
+        '1d 1h'
+    """
+    if seconds < 0:
+        return "0s"
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, sec = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {sec}s"
+    hours, m = divmod(minutes, 60)
+    if hours < 24:
+        return f"{hours}h {m}m"
+    days, h = divmod(hours, 24)
+    return f"{days}d {h}h"
+
+
+class SessionWarmup:
+    """Assemble session context in a single call.
+
+    Runs 5 independent signals (git state, CoDocs coverage, ceo-audit grade,
+    top-risk file scan, last commit time) and returns a structured summary
+    with a single ``session_recommendation`` field — so the agent can decide
+    "ready" vs "fix first" in one read.
+    """
+
+    def __init__(self, repo_root: Optional[Path] = None) -> None:
+        self.repo_root = Path(repo_root) if repo_root else Path.cwd()
+
+    def warmup(self) -> Dict[str, Any]:
+        """Gather all session signals.
+
+        Returns a dict with the following keys (always present, default
+        values on failure): ``branch``, ``git_state``, ``git_changes_count``,
+        ``last_commit_age``, ``codocs_coverage``, ``ceo_audit_grade``,
+        ``top_risks``, ``session_recommendation``, ``signals``.
+        """
+        signals: Dict[str, Any] = {}
+
+        # ── 1. Git state ─────────────────────────────────────────────
+        signals["git"] = self._git_state()
+
+        # ── 2. CoDocs coverage ───────────────────────────────────────
+        signals["codocs"] = self._codocs_coverage()
+
+        # ── 3. ceo-audit (best-effort, no cache here — caller's job) ─
+        signals["ceo_audit"] = self._ceo_audit_quick()
+
+        # ── 4. Top risks (file-level complexity heuristic) ───────────
+        signals["top_risks"] = self._top_risks()
+
+        # ── 5. Last commit time ──────────────────────────────────────
+        signals["last_commit"] = self._last_commit_age()
+
+        # ── Compose final summary ────────────────────────────────────
+        branch = signals["git"].get("branch") or "unknown"
+        git_clean = signals["git"].get("clean", False)
+        docs_ok = signals["codocs"].get("ok", True)
+        audit_grade = signals["ceo_audit"].get("grade") or "UNKNOWN"
+        top_risks = signals["top_risks"]
+
+        verdict = self._verdict(
+            git_clean=git_clean,
+            docs_ok=docs_ok,
+            audit_grade=audit_grade,
+            top_risks=top_risks,
+        )
+
+        return {
+            "branch": branch,
+            "git_state": "clean" if git_clean else "dirty",
+            "git_changes_count": signals["git"].get("changes_count", 0),
+            "last_commit_age": signals["last_commit"].get("age_human"),
+            "codocs_coverage": {
+                "ok": docs_ok,
+                "broken": signals["codocs"].get("broken", 0),
+                "checked": signals["codocs"].get("checked", 0),
+            },
+            "ceo_audit_grade": audit_grade,
+            "ceo_audit_path": signals["ceo_audit"].get("report_path"),
+            "top_risks": top_risks[:5],
+            "session_recommendation": verdict,
+            "signals": signals,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+
+    # ── helpers ─────────────────────────────────────────────────────
+    def _git_state(self) -> Dict[str, Any]:
+        try:
+            branch = (
+                subprocess.run(
+                    ["git", "branch", "--show-current"],
+                    cwd=self.repo_root,
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                ).stdout.strip()
+                or "(detached)"
+            )
+            status = subprocess.run(
+                ["git", "status", "--porcelain"],
+                cwd=self.repo_root,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            ).stdout.strip()
+            changes = status.splitlines() if status else []
+            return {
+                "ok": True,
+                "branch": branch,
+                "clean": not bool(changes),
+                "changes_count": len(changes),
+            }
+        except Exception as exc:
+            return {"ok": False, "error": str(exc), "branch": None, "clean": False}
+
+    def _codocs_coverage(self) -> Dict[str, Any]:
+        try:
+            from . import codocs
+
+            broken = codocs.find_broken(str(self.repo_root))
+            return {"ok": not bool(broken), "broken": len(broken), "checked": "auto"}
+        except Exception as exc:
+            return {"ok": True, "broken": 0, "error": str(exc)}
+
+    def _ceo_audit_quick(self) -> Dict[str, Any]:
+        try:
+            sin_bin = shutil.which("sin") or _CEO_AUDIT_FALLBACK
+            if not Path(sin_bin).exists():
+                return {"ok": False, "grade": None, "error": "sin CLI not installed"}
+            proc = subprocess.run(
+                [sin_bin, "ceo-audit", "run", str(self.repo_root), "--profile=QUICK", "--json"],
+                capture_output=True,
+                text=True,
+                timeout=180,  # 3min ceiling; QUICK profile is normally < 1min
+            )
+            if proc.returncode == 0 and proc.stdout.strip():
+                data = json.loads(proc.stdout)
+                return {
+                    "ok": True,
+                    "grade": data.get("grade"),
+                    "report_path": data.get("report_path"),
+                }
+            return {"ok": False, "grade": None, "error": proc.stderr[-300:]}
+        except (subprocess.TimeoutExpired, json.JSONDecodeError) as exc:
+            return {"ok": False, "grade": None, "error": str(exc)}
+        except Exception as exc:
+            return {"ok": False, "grade": None, "error": str(exc)}
+
+    def _top_risks(self) -> List[Dict[str, Any]]:
+        """Heuristic: largest 5 Python files by line count are 'top risks'.
+
+        Cheap proxy for "where could go wrong". Returns up to 5 entries with
+        ``path`` and ``lines``. No external tool required.
+        """
+        try:
+            files: List[Dict[str, Any]] = []
+            for p in self.repo_root.rglob("*.py"):
+                rel = p.relative_to(self.repo_root)
+                if any(
+                    part.startswith(".") or part in {"__pycache__", "node_modules", "venv", ".venv"}
+                    for part in rel.parts
+                ):
+                    continue
+                try:
+                    n = sum(1 for _ in p.open("r", encoding="utf-8", errors="ignore"))
+                except Exception:
+                    continue
+                if n > 200:  # Only flag meaningfully large files
+                    files.append({"path": str(rel), "lines": n})
+            files.sort(key=lambda x: x["lines"], reverse=True)
+            return files[:5]
+        except Exception:
+            return []
+
+    def _last_commit_age(self) -> Dict[str, Any]:
+        try:
+            proc = subprocess.run(
+                ["git", "log", "-1", "--format=%ct"],
+                cwd=self.repo_root,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if proc.returncode == 0 and proc.stdout.strip():
+                ts = int(proc.stdout.strip())
+                age_sec = int(datetime.now(timezone.utc).timestamp()) - ts
+                return {"ok": True, "age_sec": age_sec, "age_human": _human_age(age_sec)}
+            return {"ok": False, "age_human": "unknown"}
+        except Exception as exc:
+            return {"ok": False, "error": str(exc), "age_human": "unknown"}
+
+    def _verdict(
+        self,
+        git_clean: bool,
+        docs_ok: bool,
+        audit_grade: str,
+        top_risks: List[Dict[str, Any]],
+    ) -> str:
+        """Single-line recommendation for the agent.
+
+        Logic, in order:
+        1. ceo-audit F → "BLOCK — fix critical issues first"
+        2. ceo-audit D or many broken docs → "FIX — improve before coding"
+        3. Dirty tree with > 20 changes → "STASH or COMMIT first"
+        4. Everything else → "READY — proceed with coding"
+        """
+        grade = (audit_grade or "UNKNOWN").upper()
+        if grade == "F":
+            return "BLOCK — ceo-audit grade F. Fix critical issues first."
+        if grade == "D" or (not docs_ok and len(top_risks) > 0):
+            return "FIX — improve docs/quality before coding"
+        if not git_clean:
+            return "STASH or COMMIT first — working tree dirty"
+        return "READY — proceed with coding"

sin_code_bundle/skills.py

@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: MIT
+"""Compile portable SIN skills into each agent's native command/skill format.
+
+One source of truth: `skills/*.md` with YAML frontmatter (name, description,
+arguments) + a prompt body. `compile_skills()` renders them into:
+
+- opencode -> .opencode/command/<name>.md        (frontmatter: description, agent)
+- codex    -> ~/.codex/prompts/<name>.md          (plain prompt, $N positional args)
+- claude   -> .claude/skills/<name>/SKILL.md       (frontmatter: name, description)
+
+This mirrors how cross-agent tools (Ulis/Nexel) keep a single prompt library in
+sync across CLIs.
+
+Docs: skills.doc.md
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover
+    # pyyaml is optional at import time so that ``import sin_code_bundle.skills``
+    # never fails. Parsing functions raise a clear error instead. This lets the
+    # module be loaded in slim CI environments that don't need YAML support.
+    yaml = None  # type: ignore
+
+# ── Targets & Schemas ────────────────────────────────────────────────
+
+# Supported target agents. Adding a new target requires:
+#   1. extend the ``Target`` literal
+#   2. add a branch in :func:`render_skill`
+#   3. decide where it writes (per-user, per-repo, etc.)
+Target = Literal["opencode", "codex", "claude"]
+SUPPORTED_TARGETS: tuple[Target, ...] = ("opencode", "codex", "claude")
+
+# Matches the standard YAML frontmatter used by our skills/*.md sources.
+# Captures (yaml_meta, body). The trailing ``.*$`` with DOTALL lets the body
+# span newlines so multi-paragraph prompts round-trip cleanly.
+_FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n(.*)$", re.DOTALL)
+
+
+# ── Skill Model ──────────────────────────────────────────────────────
+
+
+@dataclass
+class Skill:
+    """A parsed source skill (one ``skills/*.md`` file).
+
+    Attributes:
+        name: Stable identifier — used as the filename in every target's
+            output. Falls back to the source filename stem if the frontmatter
+            omits it.
+        description: One-line summary shown in command pickers.
+        body: Prompt body, with YAML frontmatter stripped.
+        arguments: List of argument descriptors (each a dict with at least a
+            ``"name"`` key). Used to template ``{{name}}`` placeholders when
+            rendering to codex (which expects positional ``$N``).
+    """
+
+    name: str
+    description: str
+    body: str
+    arguments: list[dict] = field(default_factory=list)
+
+    @classmethod
+    def parse(cls, path: Path) -> "Skill":
+        """Parse a single ``skills/*.md`` file into a :class:`Skill`.
+
+        Args:
+            path: Filesystem path to a markdown file with YAML frontmatter
+                delimited by ``---`` fences.
+
+        Returns:
+            The parsed :class:`Skill`.
+
+        Raises:
+            ValueError: If the file is missing the YAML frontmatter block.
+            RuntimeError: If PyYAML is not installed in the environment.
+        """
+        text = path.read_text(encoding="utf-8")
+        m = _FRONTMATTER_RE.match(text)
+        if not m:
+            raise ValueError(f"{path} is missing YAML frontmatter")
+        if yaml is None:
+            raise RuntimeError("pyyaml is required to parse skills")
+        meta = yaml.safe_load(m.group(1)) or {}
+        return cls(
+            name=meta.get("name", path.stem),
+            description=meta.get("description", ""),
+            body=m.group(2).strip(),
+            arguments=meta.get("arguments", []) or [],
+        )
+
+
+# ── Rendering ────────────────────────────────────────────────────────
+
+
+def _body_for_codex(skill: Skill) -> str:
+    """Codex prompts use positional $1, $2 ... — map {{arg}} -> $N."""
+    body = skill.body
+    for i, arg in enumerate(skill.arguments, start=1):
+        body = body.replace("{{" + arg["name"] + "}}", f"${i}")
+    return body
+
+
+def render_skill(skill: Skill, target: Target) -> tuple[str, str]:
+    """Return (relative_output_path, file_content) for a target agent.
+
+    The relative output path is interpreted relative to the base directory
+    chosen by :func:`compile_skills` (per-user for codex, per-repo for the
+    others). The path includes a trailing filename and parent directory so
+    callers only have to ``open`` it for writing.
+    """
+    if target == "opencode":
+        # ``agent: build`` is the default opencode sub-agent that runs custom
+        # commands; we hard-code it here because all our skills target it.
+        fm = f"---\ndescription: {skill.description}\nagent: build\n---\n\n"
+        return f".opencode/command/{skill.name}.md", fm + skill.body + "\n"
+
+    if target == "codex":
+        # codex uses ``prompts/`` (not dot-prefixed) and a flat layout under
+        # ~/.codex — no frontmatter, just the templated body.
+        return f"prompts/{skill.name}.md", _body_for_codex(skill) + "\n"
+
+    if target == "claude":
+        # claude skills live in a per-skill subdirectory with a fixed
+        # ``SKILL.md`` name — that's the convention their loader expects.
+        fm = f"---\nname: {skill.name}\ndescription: {skill.description}\n---\n\n"
+        return f".claude/skills/{skill.name}/SKILL.md", fm + skill.body + "\n"
+
+    raise ValueError(f"unknown target: {target}")
+
+
+# ── Discovery & Compilation ──────────────────────────────────────────
+
+
+def load_skills(source_dir: Path = Path("skills")) -> list[Skill]:
+    """Load every ``*.md`` file under ``source_dir`` as a :class:`Skill`.
+
+    Returns an empty list if ``source_dir`` does not exist (e.g. running
+    in a clone that hasn't checked out the skills library). The result is
+    sorted by filename for deterministic, diff-friendly output ordering.
+    """
+    if not source_dir.exists():
+        return []
+    return [Skill.parse(p) for p in sorted(source_dir.glob("*.md"))]
+
+
+def compile_skills(
+    target: Target,
+    source_dir: Path = Path("skills"),
+    out_root: Path = Path("."),
+    dry_run: bool = False,
+) -> list[Path]:
+    """Compile every source skill into `target`'s native format.
+
+    For codex, paths are written under the user's ~/.codex/; for opencode and
+    claude they are written relative to the repo (out_root).
+
+    Args:
+        target: Which agent to render for.
+        source_dir: Directory containing ``*.md`` source skills.
+        out_root: Base directory for opencode/claude outputs (ignored for
+            codex, which always lands under ``~/.codex``).
+        dry_run: If True, return the would-be destination paths without
+            writing files or creating parent directories.
+
+    Returns:
+        A list of destination paths in the same order as the source skills.
+    """
+    written: list[Path] = []
+    # codex installs prompts per-user (other agents are per-repo), so its
+    # base dir is fixed to ~/.codex regardless of out_root.
+    base = Path.home() / ".codex" if target == "codex" else out_root
+
+    for skill in load_skills(source_dir):
+        rel, content = render_skill(skill, target)
+        dest = base / rel
+        written.append(dest)
+        if not dry_run:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_text(content, encoding="utf-8")
+    return written

sin_code_bundle/symbol_resolve.py

@@ -0,0 +1,166 @@
+# Purpose: Unified code archaeology — graph + cross-source context in 1 call.
+# Docs: symbol_resolve.doc.md
+"""Consolidates gitnexus_query + gitnexus_context + gitnexus_impact +
+gitnexus_detect_changes. Also integrates sin-context-bridge for cross-source
+context (memory, code knowledge graph).
+
+Docs: symbol_resolve.doc.md
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Default binary names we look up on PATH. Hard-coded fallback paths exist
+# for the dev machine layout documented in AGENTS.md so the tool keeps
+# working when PATH is restricted (e.g. inside the MCP stdio process).
+_GITNEXUS_FALLBACK = "/Users/jeremy/Library/Python/3.14/bin/gitnexus"
+_CONTEXT_BRIDGE_FALLBACK = "/Users/jeremy/Library/Python/3.14/bin/sin-context-bridge"
+
+
+class SymbolResolver:
+    """One-call code archaeology for any symbol.
+
+    Fans out to gitnexus primitives + sin-context-bridge. Each source
+    degrades independently — missing CLI or failing command leaves the
+    result empty but does not raise.
+    """
+
+    def __init__(self, repo_root: Optional[Path] = None) -> None:
+        self.repo_root = Path(repo_root) if repo_root else Path.cwd()
+
+    def resolve(
+        self,
+        name: str,
+        depth: int = 2,
+        include: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Resolve a symbol via multiple graph queries.
+
+        Args:
+            name: function, class, or module name.
+            depth: 1-3 levels of graph traversal.
+            include: subset of {callers, callees, blast, recent, cross}.
+                Defaults to all except ``cross``.
+
+        Returns:
+            Dict with per-source slices and a ``sources_queried`` list
+            showing which CLIs responded successfully.
+        """
+        if include is None:
+            include = ["callers", "callees", "blast", "recent"]
+
+        # ── Resolve binaries ────────────────────────────────────────────
+        # shutil.which is the canonical way to find a CLI on PATH; the
+        # hard-coded fallbacks cover the dev-machine layout from AGENTS.md.
+        gitnexus_bin = shutil.which("gitnexus") or _GITNEXUS_FALLBACK
+        context_bridge_bin = shutil.which("sin-context-bridge") or _CONTEXT_BRIDGE_FALLBACK
+
+        result: Dict[str, Any] = {
+            "symbol": name,
+            "depth": depth,
+            "include": include,
+            "callers": [],
+            "callees": [],
+            "blast_radius": {},
+            "recent_changes": [],
+            "cross_source": {},
+            "sources_queried": [],
+        }
+
+        # ── 1. Callers + callees (gitnexus context) ─────────────────────
+        # One CLI call feeds both slices — same JSON payload.
+        if ("callers" in include or "callees" in include) and Path(gitnexus_bin).exists():
+            try:
+                proc = subprocess.run(
+                    [gitnexus_bin, "context", name, "--json"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if proc.returncode == 0 and proc.stdout.strip():
+                    data = json.loads(proc.stdout)
+                    if "callers" in include:
+                        result["callers"] = data.get("callers", [])
+                    if "callees" in include:
+                        result["callees"] = data.get("callees", [])
+                    result["sources_queried"].append("gitnexus:context")
+            except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
+                # Graceful degradation — leave the slice empty.
+                pass
+
+        # ── 2. Blast radius (gitnexus impact) ───────────────────────────
+        # Groups affected symbols by traversal depth for risk assessment.
+        if "blast" in include and Path(gitnexus_bin).exists():
+            try:
+                proc = subprocess.run(
+                    [gitnexus_bin, "impact", json.dumps({"target": name})],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if proc.returncode == 0 and proc.stdout.strip():
+                    data = json.loads(proc.stdout)
+                    affected = data.get("affected", [])
+                    for item in affected:
+                        d = item.get("depth", 1)
+                        result["blast_radius"].setdefault(f"d{d}", []).append(item)
+                    result["sources_queried"].append("gitnexus:impact")
+            except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
+                pass
+
+        # ── 3. Recent changes (gitnexus detect-changes) ─────────────────
+        # Filters to changes mentioning the symbol — useful for "is this
+        # currently being modified?" answers.
+        if "recent" in include and Path(gitnexus_bin).exists():
+            try:
+                proc = subprocess.run(
+                    [gitnexus_bin, "detect-changes", "--json"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if proc.returncode == 0 and proc.stdout.strip():
+                    data = json.loads(proc.stdout)
+                    all_changes = data.get("changes", [])
+                    # Filter cheaply by checking each change dict's JSON
+                    # representation; cheaper than traversing every field.
+                    result["recent_changes"] = [
+                        c for c in all_changes if name.lower() in json.dumps(c).lower()
+                    ]
+                    result["sources_queried"].append("gitnexus:detect-changes")
+            except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
+                pass
+
+        # ── 4. Cross-source (sin-context-bridge) ────────────────────────
+        # Bridges local SCKG + remote sin-brain + local memory into one view.
+        if "cross" in include and Path(context_bridge_bin).exists():
+            try:
+                proc = subprocess.run(
+                    [
+                        context_bridge_bin,
+                        "query",
+                        name,
+                        "--sources",
+                        "sckg,sin_brain,local",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=15,
+                )
+                if proc.returncode == 0 and proc.stdout.strip():
+                    data = json.loads(proc.stdout)
+                    result["cross_source"] = {
+                        "query": name,
+                        "chunks": data.get("chunks", []),
+                        "sources_queried": data.get("sources_queried", []),
+                    }
+                    result["sources_queried"].append("sin-context-bridge")
+            except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
+                pass
+
+        return result

sin_code_bundle/tools/__init__.py

@@ -0,0 +1,4 @@
+"""Maintainer tools bundled with sin-code-bundle.
+
+Docs: __init__.doc.md
+"""