boost-skill-cli 1.0.204__tar.gz → 1.0.206__tar.gz

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/Makefile

@@ -51,6 +51,7 @@ lint:
 	$(VENV)/bin/vulture boost_cli --min-confidence 80
 	$(VENV)/bin/xenon --max-absolute F --max-modules E --max-average B boost_cli
 	$(VENV)/bin/interrogate boost_cli/core
+	$(VENV)/bin/refurb boost_cli
 	$(VENV)/bin/codespell boost_cli docs README.md
 	@command -v actionlint >/dev/null 2>&1 && actionlint || echo "actionlint not on PATH — skipping (CI enforces it)"
 	$(PY) scripts/build_registries.py --check

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.204
+Version: 1.0.206
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/__init__.py

@@ -1,4 +1,5 @@
 """boost — Homebrew for AI coding skills."""
+from contextlib import suppress
 
 
 def _detect_version() -> str:
@@ -8,17 +9,13 @@ def _detect_version() -> str:
     package metadata, then a git-checkout fallback (stdlib only, so the
     dependency-free runtime stays intact), then a sentinel.
     """
-    try:
+    with suppress(Exception):
         from ._version import version as scm_version
         return scm_version
-    except Exception:
-        pass
-    try:
+    with suppress(Exception):
         from importlib.metadata import version as dist_version
         return dist_version("boost-skill-cli")
-    except Exception:
-        pass
-    try:
+    with suppress(Exception):
         import subprocess
         from pathlib import Path
         root = Path(__file__).resolve().parent.parent
@@ -28,8 +25,6 @@ def _detect_version() -> str:
         described = proc.stdout.strip()
         if proc.returncode == 0 and described:
             return described.lstrip("v")
-    except Exception:
-        pass
     return "0.0.0+unknown"
 
 

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.204'
-__version_tuple__ = version_tuple = (1, 0, 204)
+__version__ = version = '1.0.206'
+__version_tuple__ = version_tuple = (1, 0, 206)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/bmad.py

@@ -27,6 +27,7 @@ import shlex
 import shutil
 import subprocess
 import tempfile
+from contextlib import suppress
 from pathlib import Path
 
 from .. import cliparse
@@ -110,7 +111,7 @@ def _require_npx() -> None:
             hint="install Node.js 20.12+ (e.g. `brew install node`), then retry")
 
 
-def _run_installer(directory: Path, modules: str) -> "subprocess.CompletedProcess":
+def _run_installer(directory: Path, modules: str) -> subprocess.CompletedProcess:
     cmd = ["npx", "--yes", "bmad-method@latest", "install",
            "--yes", "--directory", str(directory),
            "--tools", "claude-code", "--modules", modules,
@@ -136,7 +137,7 @@ def _whoami() -> str:
 
 
 def _parse_version(text: str) -> str:
-    m = re.search(r"v(\d+\.\d+\.\d+)", text or "")
+    m = re.search(r"v(\d+\.\d+\.\d+)", text)
     return m.group(1) if m else "unknown"
 
 
@@ -225,11 +226,9 @@ def _startup(value, scope) -> int:
 def _orient(scope) -> int:
     """SessionStart hook target: print orientation iff enabled (else silent)."""
     scope = scope or "project"
-    try:
+    with suppress(Exception):  # a hook must never break the session
         if _get_scope_state(scope).get("startup"):
             print(ORIENT)
-    except Exception:
-        pass  # a hook must never break the session
     return 0
 
 

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/configuration.py

@@ -793,8 +793,8 @@ def _tool_info(args: dict):
     if src.get("description"):
         lines.append("description: %s" % src["description"])
     if entry:
-        lines.append("installed: yes (%s)" % entry.get("installed_at", "?"))
-        lines.append("agents: %s" % (", ".join(entry.get("agents") or []) or "none"))
+        lines.extend(("installed: yes (%s)" % entry.get("installed_at", "?"),
+                      "agents: %s" % (", ".join(entry.get("agents") or []) or "none")))
         if entry.get("pinned"):
             lines.append("pinned: yes")
     else:

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/discovery.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import operator
 import re
 import shutil
 import subprocess
@@ -43,7 +44,7 @@ _tilde = paths.tilde
 
 def _json_array(text):
     """Best-effort extraction of the first JSON array in an AI reply."""
-    m = re.search(r"\[.*\]", text or "", re.S)
+    m = re.search(r"\[.*\]", text or "", re.DOTALL)
     if not m:
         return None
     try:
@@ -108,7 +109,7 @@ def cmd_search(argv):
     else:
         scored = catalog.search(query)
     if args.as_json:
-        print(json.dumps([dict(e, score=s) for e, s in scored[:args.limit]]))
+        print(json.dumps([e | {"score": s} for e, s in scored[:args.limit]]))
         return 0
     if not scored:
         out.info("no matches for %r" % query)
@@ -412,7 +413,7 @@ def cmd_recommend(argv):
                     key=lambda r: (-r["score"], r["entry"]["name"]))
     if args.as_json:
         print(json.dumps({"stack": stack, "recommendations": [
-            dict(r["entry"], score=r["score"], because=sorted(r["because"]))
+            r["entry"] | {"score": r["score"], "because": sorted(r["because"])}
             for r in ranked[:args.limit]]}))
         return 0
     line = "stack: " + (", ".join(stack["languages"]) or "unknown")
@@ -833,7 +834,7 @@ def cmd_browse(argv):
         prog="boost browse",
         description="Interactive full-screen TUI with fuzzy search")
     p.parse_args(argv)
-    entries = sorted(catalog.all_entries(), key=lambda e: e["name"])
+    entries = sorted(catalog.all_entries(), key=operator.itemgetter("name"))
     if not entries:
         raise BoostError("no skills available to browse",
                         hint="add registries with `boost tap --defaults`")
@@ -886,7 +887,7 @@ def cmd_trending(argv):
         descw = max(out.term_width() - 24, 24)  # reserve name + version columns
         out.table([(e["name"], "v" + e["version"],
                     out.truncate(e["description"], descw))
-                   for e in sorted(curated, key=lambda e: e["name"])[:args.limit]])
+                   for e in sorted(curated, key=operator.itemgetter("name"))[:args.limit]])
         return 0
     agg = {}
     for ev in evs:  # most-recent-first, so first ts per subject is the latest
@@ -924,13 +925,11 @@ def cmd_stats(argv):
     latest = cat["version"] if cat else None
     upstream = None
     if cat:
-        try:
+        with contextlib.suppress(BoostError):
             tap = registry.get(cat["tap"])
             if tap.is_cloned:
                 lines = gitutil.log_for_path(tap.path, cat["rel_dir"], n=1)
                 upstream = lines[0] if lines else None
-        except BoostError:
-            pass
     sdir = store.skill_store_dir(name)
     size = util.dir_size(sdir) if lock and sdir.is_dir() else None
     if args.as_json:

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/info.py

@@ -495,7 +495,7 @@ def cmd_explain(argv):
     desc = str(meta.get("description") or "").strip()
     if desc:
         _print_wrapped(desc)
-    headings = re.findall(r"^(#{1,6})\s+(.*)$", body, re.M)
+    headings = re.findall(r"^(#{1,6})\s+(.*)$", body, re.MULTILINE)
     if headings:
         print()
         out.info(out.c("Outline:", out.BOLD))

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/intelligence.py

@@ -418,7 +418,7 @@ def _commit_rule(style: Tuple[int, int]) -> str:
 def _infer_ai(name: str, root: Path, facts: dict) -> Optional[str]:
     listing = ", ".join(sorted(p.name for p in root.iterdir()
                                if not p.name.startswith("."))[:30])
-    detected = dict(facts)
+    detected = facts.copy()
     if detected.get("commit_style"):
         detected["commit_style"] = _commit_rule(detected["commit_style"])
     reply = ai.ask_author(

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/pkg.py

@@ -165,7 +165,7 @@ def _boostfile_text(skills: Dict[str, dict], via: str = "boost bundle dump") ->
 
 def _rel_list(meta: dict, key: str) -> List[str]:
     """A skill's `requires:`/`conflicts:` frontmatter as a clean name list."""
-    val = (meta or {}).get(key)
+    val = meta.get(key)
     if val in (None, "", False):
         return []
     if isinstance(val, list):
@@ -181,7 +181,7 @@ def _skill_relations(name: str, key: str) -> List[str]:
     return _rel_list(matches[0].get("meta") or {}, key)
 
 
-def _expand_dependencies(entries: List[dict]) -> "tuple[List[dict], resolve.Resolution]":
+def _expand_dependencies(entries: List[dict]) -> tuple[List[dict], resolve.Resolution]:
     """Grow the requested entries into their full `requires:` closure.
 
     Returns ``(ordered_entries, resolution)`` — the entries to install in
@@ -391,7 +391,7 @@ def cmd_uninstall(argv: List[str]) -> int:
         removed += 1
     if removed:
         lines = ["Uninstalled %s" % _plural(removed, "skill")]
-        if removed == 1 and len(args.names) == 1:
+        if removed == 1 == len(args.names):
             lines.append(out.role("next: boost list", "muted"))
         print(out.panel(lines, title="removed", hue="pink"))
     return 1 if failed else 0
@@ -425,7 +425,7 @@ def cmd_sync(argv: List[str]) -> int:
 
     if args.diff:
         if args.json:
-            print(json.dumps(dict(plan, project=pplan), indent=2))
+            print(json.dumps(plan | {"project": pplan}, indent=2))
             return 0
         if not any(plan.values()) and not any(pplan.values()):
             out.ok("everything in sync")

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/quality.py

@@ -11,7 +11,9 @@ import hashlib
 import json
 import os
 import re
+from contextlib import suppress
 from datetime import datetime, timedelta, timezone
+from itertools import starmap
 from pathlib import Path
 from typing import List, Optional, Tuple
 
@@ -150,13 +152,11 @@ def _stack_keywords(cwd: Path) -> set:
     detect_stack keywords, enriched with coarse filesystem markers (so tags
     like `testing` or `git` can match even when detect_stack is language-only)."""
     kws: List[str] = []
-    try:
+    with suppress(Exception):
         from ..core.stackprobe import detect_stack
         stack = detect_stack(cwd)
         if isinstance(stack, dict):
             kws.extend(str(k) for k in (stack.get("keywords") or []))
-    except Exception:
-        pass
     for marker, words in _STACK_MARKERS:
         if (Path(cwd) / marker).exists():
             kws.extend(words)
@@ -906,7 +906,7 @@ def cmd_trust(argv) -> int:
         else:
             results = _tap_provenance_rows()
         if args.json:
-            print(json.dumps([_result_json(n, r) for n, r in results], indent=2))
+            print(json.dumps(list(starmap(_result_json, results)), indent=2))
         else:
             _print_provenance(results)
         # A specific tap must verify; a full sweep only alarms on tampering.
@@ -922,7 +922,7 @@ def cmd_trust(argv) -> int:
             "trusted_keys": [{"name": k["name"],
                               "fingerprint": k.get("fingerprint", "")}
                              for k in keys],
-            "taps": [_result_json(n, r) for n, r in taps],
+            "taps": list(starmap(_result_json, taps)),
         }, indent=2))
         return 0
     out.heading("trusted keys")
@@ -936,7 +936,7 @@ def cmd_trust(argv) -> int:
     return 0
 
 
-def _result_json(tap_name: str, r: "provenance.Result") -> dict:
+def _result_json(tap_name: str, r: provenance.Result) -> dict:
     return {"tap": tap_name, "status": r.status, "key_name": r.key_name,
             "fingerprint": r.fingerprint, "trusted_comment": r.trusted_comment}
 

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/run.py

@@ -18,6 +18,7 @@ import os
 import subprocess
 import sys
 import tempfile
+from pathlib import Path
 from typing import List
 
 from .. import cliparse
@@ -111,6 +112,6 @@ def _execute(runner: str, display: str, model, target) -> int:  # pragma: no cov
         proc = subprocess.run([sys.executable, runner_path])
     finally:
         with contextlib.suppress(OSError):
-            os.unlink(runner_path)
+            Path(runner_path).unlink()
     journal.log("run", display)
     return proc.returncode

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/safety.py

@@ -23,7 +23,7 @@ from ._common import _iter_installed, _s
 _AUDIT_PATTERNS = [
     (re.compile(r"(?:curl|wget)[^|\n]*\|\s*(?:sudo\s+)?(?:ba|z|da)?sh\b"),
      "HIGH", "remote-exec"),
-    (re.compile(r"rm\s+-(?:rf|fr)\s+(?:/|~)(?=[\s'\";`)]|$)", re.M),
+    (re.compile(r"rm\s+-(?:rf|fr)\s+(?:/|~)(?=[\s'\";`)]|$)", re.MULTILINE),
      "HIGH", "destructive"),
     (re.compile(r"base64\s+(?:-d|-D|--decode)\b[^\n]*\|\s*(?:ba|z)?sh\b"),
      "HIGH", "obfuscated-exec"),

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/commands/taps.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import argparse
 import json
+from contextlib import suppress
 
 from .. import cliparse, spin
 from ..core import catalog, config, gitutil, journal, lockfile, paths, registry, staleness, store, util
@@ -145,17 +146,15 @@ def cmd_untap(argv) -> int:
     return 0
 
 
-def _tap_updated(tap: "registry.Tap") -> str:
+def _tap_updated(tap: registry.Tap) -> str:
     """Last-commit date of a tap clone, else the cache's generated age."""
     if tap.is_cloned:
-        try:
+        with suppress(BoostError):
             # --date=short --format=%cd == %cs, but works on git < 2.21 too
             proc = gitutil.run(["-C", str(tap.path), "log", "-1",
                                 "--date=short", "--format=%cd"], check=False)
             if proc.returncode == 0 and proc.stdout.strip():
                 return proc.stdout.strip()
-        except BoostError:
-            pass
     try:
         data = json.loads(tap.cache_file.read_text(encoding="utf-8"))
         return util.rel_time(data.get("generated", ""))

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/adapters.py

@@ -26,7 +26,7 @@ from . import frontmatter
 
 # Public: the format id shown in `--to`/errors -> its renderer.
 # Populated at the bottom once the render_* functions are defined.
-FORMATS: Dict[str, "Callable[..., str]"] = {}
+FORMATS: Dict[str, Callable[..., str]] = {}
 
 # Subagent (crew member) directories: a Markdown file under one of these, at any
 # depth beneath a skill, is one of the skill's subagents — so both a flat
@@ -401,10 +401,8 @@ def render_crew(workflow: str, description: str, specs: List[AgentSpec],
 
     parts = [_crew_header("crewai", workflow, description), "\n".join(imports) + "\n", "\n"]
     if tools:
-        parts.append("\n".join(_tool_stub(t, "@tool(%s)" % _py_str(t)) for t in tools))
-        parts.append("\n")
-    parts.append("\n".join(blocks))
-    parts.append("\n" + crew)
+        parts.extend(("\n".join(_tool_stub(t, "@tool(%s)" % _py_str(t)) for t in tools), "\n"))
+    parts.extend(("\n".join(blocks), "\n" + crew))
     return "".join(parts)
 
 
@@ -439,25 +437,22 @@ def render_graph(workflow: str, description: str, specs: List[AgentSpec],
         for ident, spec in zip(idents, specs))
     lines.append("")
     for ident in idents:
-        lines.append("    def %s_node(state):" % ident)
-        lines.append("        return {\"messages\": %s.invoke(state)[\"messages\"]}" % ident)
-    lines.append("")
-    lines.append("    builder = StateGraph(MessagesState)")
+        lines.extend(("    def %s_node(state):" % ident,
+                      "        return {\"messages\": %s.invoke(state)[\"messages\"]}" % ident))
+    lines.extend(("", "    builder = StateGraph(MessagesState)"))
     lines.extend("    builder.add_node(%s, %s_node)" % (_py_str(ident), ident)
                  for ident in idents)
     prev = "START"
     for ident in idents:
         lines.append("    builder.add_edge(%s, %s)" % (prev, _py_str(ident)))
         prev = _py_str(ident)
-    lines.append("    builder.add_edge(%s, END)" % prev)
-    lines.append("    return builder.compile()")
+    lines.extend(("    builder.add_edge(%s, END)" % prev, "    return builder.compile()"))
     factory = "def build_%s(%s):\n%s\n" % (_ident(workflow), sig, "\n".join(lines))
 
     parts = [_crew_header("langgraph", workflow, description),
              "\n".join(imports) + "\n", "\n", prompts, "\n"]
     if tools:
-        parts.append("\n".join(_tool_stub(t, "@tool") for t in tools))
-        parts.append("\n\n")
+        parts.extend(("\n".join(_tool_stub(t, "@tool") for t in tools), "\n\n"))
     parts.append(factory)
     return "".join(parts)
 
@@ -465,7 +460,7 @@ def render_graph(workflow: str, description: str, specs: List[AgentSpec],
 # Multi-agent (crew/graph) renderers, keyed by the same format id as FORMATS.
 # A format absent here has no multi-agent path; the command layer falls back to
 # the single-agent renderer (flattening the skill to its primary agent).
-MULTI_FORMATS: Dict[str, "Callable[..., str]"] = {
+MULTI_FORMATS: Dict[str, Callable[..., str]] = {
     "crewai": render_crew,
     "langgraph": render_graph,
 }

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/ai.py

@@ -111,7 +111,9 @@ def _ask_api(prompt: str, system: Optional[str], model: str,
 
 def extract_markdown(text: str) -> str:
     """Strip a ```markdown fence if the model wrapped its answer in one."""
-    t = (text or "").strip()
+    # `or ""`: callers hand this a model reply, which is None when the call
+    # failed — tolerating None here is tested behavior, not dead defense.
+    t = (text or "").strip()  # noqa: FURB143
     if t.startswith("```"):
         lines = t.splitlines()
         if lines[0].startswith("```"):

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/capabilities.py

@@ -30,7 +30,7 @@ from typing import List, Set
 NETWORK = "network"
 SHELL = "shell"
 FILESYSTEM = "filesystem"
-KNOWN: "tuple[str, ...]" = (NETWORK, SHELL, FILESYSTEM)
+KNOWN: tuple[str, ...] = (NETWORK, SHELL, FILESYSTEM)
 
 # Aliases an author might write for a bucket, folded to the canonical name.
 _ALIASES = {
@@ -60,7 +60,8 @@ _TELLS = {
         r"\bwrite_text\b", r"\bopen\([^)]*['\"][wa]", r"\brmdir\b",
     ],
 }
-_COMPILED = {cap: [re.compile(p, re.I) for p in pats] for cap, pats in _TELLS.items()}
+_COMPILED = {cap: [re.compile(p, re.IGNORECASE) for p in pats]
+             for cap, pats in _TELLS.items()}
 
 
 def declared(meta: dict) -> Set[str]:
@@ -79,7 +80,7 @@ def unknown(meta: dict) -> Set[str]:
 
 
 def _raw(meta: dict):
-    val = (meta or {}).get("capabilities")
+    val = meta.get("capabilities")
     if val in (None, "", False):
         return []
     if isinstance(val, list):

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/catalog.py

@@ -18,6 +18,7 @@ that ship in the same GitHub registries:
 from __future__ import annotations
 
 import json
+import operator
 import os
 import re
 from pathlib import Path
@@ -155,11 +156,11 @@ def scan_dir(root: Path, tap_name: str = "local", curated: bool = False) -> List
             entries.append(_make_entry(root, path, kind, default,
                                        tap_name, curated, meta, body))
 
-    entries.sort(key=lambda e: (e["skill_md"], e["name"]))
+    entries.sort(key=operator.itemgetter("skill_md", "name"))
     return entries
 
 
-def rebuild_tap(tap: "registry.Tap") -> List[dict]:
+def rebuild_tap(tap: registry.Tap) -> List[dict]:
     """Rescan a cloned tap and rewrite its JSON cache file -> entries.
 
     Raises BoostError when the tap is not cloned; also drops the
@@ -192,7 +193,7 @@ def rebuild_tap(tap: "registry.Tap") -> List[dict]:
 _ENTRY_CACHE: Dict[str, Tuple[Tuple[int, int], List[dict]]] = {}
 
 
-def _cached_tap(tap: "registry.Tap") -> Optional[List[dict]]:
+def _cached_tap(tap: registry.Tap) -> Optional[List[dict]]:
     """Memoized ``skills`` for a tap's cache file, or ``None`` to force a
     rebuild (file missing, unreadable, or corrupt JSON)."""
     p = tap.cache_file
@@ -215,7 +216,7 @@ def _cached_tap(tap: "registry.Tap") -> Optional[List[dict]]:
     return skills
 
 
-def load_tap(tap: "registry.Tap", rebuild: bool = False) -> List[dict]:
+def load_tap(tap: registry.Tap, rebuild: bool = False) -> List[dict]:
     """Return a tap's entries, from the mtime-keyed cache when fresh.
 
     `rebuild=True` or a missing/corrupt cache forces a rescan; an
@@ -244,8 +245,8 @@ def find(name: str, tap: Optional[str] = None) -> List[dict]:
         tap, name = name.rsplit(":", 1)
     matches = [e for e in all_entries() if e["name"] == name]
     if tap:
-        matches = [e for e in matches if e["tap"] == tap or
-                   e["tap"].split("/")[-1] == tap]
+        matches = [e for e in matches
+                   if tap in (e["tap"], e["tap"].split("/")[-1])]
     return matches
 
 
@@ -293,7 +294,9 @@ def _search_blob(name: str, description: str, meta) -> str:
     """The full lowercased substring-search text for an entry: its name,
     description and flattened frontmatter. Built once at index time and cached
     on the entry as ``search_blob`` so search() never rebuilds it per query."""
-    return " ".join([name.lower(), (description or "").lower(), _meta_text(meta)])
+    # `or ""` is load-bearing despite the `str` annotation: search() calls this
+    # with e.get("description", ""), which yields None when the key holds None.
+    return " ".join([name.lower(), (description or "").lower(), _meta_text(meta)])  # noqa: FURB143
 
 
 def search(query: str, entries: Optional[List[dict]] = None):

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/claude_settings.py

@@ -112,8 +112,7 @@ def add_hook(scope: str, event: str, name: str, command: str,
              project_dir: Optional[Path] = None) -> None:
     """Idempotently install a boost-managed hook (replaces same-named entry)."""
     data = load(scope, project_dir)
-    hooks = data.setdefault("hooks", {})
-    event_list = hooks.setdefault(event, [])
+    event_list = data.setdefault("hooks", {}).setdefault(event, [])
     # Drop any prior entry we own with this name so re-adding is idempotent.
     _strip(event_list, name)
     block: dict = {}

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/config.py

@@ -69,7 +69,10 @@ def load_registry_catalog() -> list:
 
 def _merge(base: dict, override: dict) -> dict:
     out = deepcopy(base)
-    for k, v in (override or {}).items():
+    # `or {}`: the only caller feeds this json.loads() of config.json, so a file
+    # holding `null` (or `[]`, or any falsy scalar) arrives here as a non-dict —
+    # a malformed config must read as "no overrides", never crash the CLI.
+    for k, v in (override or {}).items():  # noqa: FURB143
         if isinstance(v, dict) and isinstance(out.get(k), dict):
             out[k] = _merge(out[k], v)
         else:

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/dense.py

@@ -272,8 +272,8 @@ def retrieve(query: str, k: int = 60, kind: Optional[str] = None,
         if prev is None or score > prev[0]:
             best[key] = (score, snip)
     ranked = sorted(best.items(), key=lambda kv: (-kv[1][0], kv[0][0]))
-    hits: List[Hit] = []
-    for (name, tap), (score, snip) in ranked[:k]:
-        hits.append({"entry": live[(name, tap)], "score": score,
-                     "snippet": snip})  # type: ignore[typeddict-item]
+    hits: List[Hit] = [
+        {"entry": live[(name, tap)], "score": score,
+         "snippet": snip}  # type: ignore[typeddict-item]
+        for (name, tap), (score, snip) in ranked[:k]]
     return hits

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/embed.py

@@ -89,12 +89,12 @@ def embed(texts: List[str], input_type: Optional[str] = None,
     if not texts:
         return []
     if p == "voyage":
-        body = {"input": list(texts), "model": VOYAGE_MODEL}
+        body = {"input": texts.copy(), "model": VOYAGE_MODEL}
         if input_type:
             body["input_type"] = input_type
         return _vectors(_post(VOYAGE_URL, os.environ["VOYAGE_API_KEY"],
                               body, timeout), len(texts))
-    body = {"input": list(texts), "model": OPENAI_MODEL}
+    body = {"input": texts.copy(), "model": OPENAI_MODEL}
     return _vectors(_post(OPENAI_URL, os.environ["OPENAI_API_KEY"],
                           body, timeout), len(texts))
 

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/faithfulness.py

@@ -58,10 +58,8 @@ def salient_terms(s: str) -> Set[str]:
             tok = tok.strip("`.,:;()[]{}\"'")
             if tok:
                 out.add(tok.lower())
-    for m in _CODEISH.findall(s):
-        out.add(m.lower())
-    for m in _FLAG.findall(s):
-        out.add(m.lower())
+    out.update(m.lower() for m in _CODEISH.findall(s))
+    out.update(m.lower() for m in _FLAG.findall(s))
     for m in _ACRONYM.findall(s):
         if m not in _STOP_ACRONYMS:
             out.add(m.lower())

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/frontmatter.py

@@ -13,6 +13,7 @@ Supports the subset actually used by skill files:
 """
 from __future__ import annotations
 
+from contextlib import suppress
 from typing import Tuple
 
 
@@ -47,14 +48,10 @@ def _scalar(raw: str):
         return False
     if low == "null" or s == "~":
         return None
-    try:
+    with suppress(ValueError):
         return int(s)
-    except ValueError:
-        pass
-    try:
+    with suppress(ValueError):
         return float(s)
-    except ValueError:
-        pass
     return s
 
 

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/imperative.py

@@ -15,7 +15,8 @@ rule.
 from __future__ import annotations
 
 import re
-from typing import List, Match, Optional
+from typing import List, Optional
+from re import Match
 
 # An "always / never / must (not) / do not / don't" line, optionally preceded by
 # a list marker. Group 1 = the modal, group 2 = everything after it.

{boost_skill_cli-1.0.204 → boost_skill_cli-1.0.206}/boost_cli/core/injectscan.py

@@ -30,7 +30,7 @@ class Rule(NamedTuple):
     """
     id: str
     severity: str
-    pattern: "re.Pattern[str]"
+    pattern: re.Pattern[str]
     description: str
 
 
@@ -46,7 +46,7 @@ class Finding(NamedTuple):
     description: str
 
 
-def _rx(pattern: str) -> "re.Pattern[str]":
+def _rx(pattern: str) -> re.Pattern[str]:
     return re.compile(pattern, re.IGNORECASE)