boost-skill-cli 1.0.101__tar.gz → 1.0.102__tar.gz

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/PKG-INFO

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

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/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.101'
-__version_tuple__ = version_tuple = (1, 0, 101)
+__version__ = version = '1.0.102'
+__version_tuple__ = version_tuple = (1, 0, 102)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/boost_cli/commands/configuration.py

@@ -928,8 +928,15 @@ def cmd_mcp(argv) -> int:
 
     shim = paths.launcher()
     if args.action == "register":
-        cmd = ["claude", "mcp", "add", "--scope", "user", "boost", "--",
-               str(shim), "mcp", "--stdio"]
+        # Fork-safe launch env: a host that fork()s into `boost mcp --stdio`
+        # on macOS can SIGABRT on the child side *pre-exec* if Obj-C is touched
+        # post-fork (CFPreferences / _scproxy proxy lookup). Disabling the
+        # fork-safety trap and short-circuiting proxy resolution keeps the
+        # host's fork into boost from aborting before our Python ever runs.
+        cmd = ["claude", "mcp", "add", "--scope", "user",
+               "-e", "OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES",
+               "-e", "no_proxy=*",
+               "boost", "--", str(shim), "mcp", "--stdio"]
     else:
         cmd = ["claude", "mcp", "remove", "boost"]
 

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/boost_cli/core/catalog.py

@@ -21,7 +21,7 @@ import json
 import os
 import re
 from pathlib import Path
-from typing import List, Optional, Set, Tuple
+from typing import Dict, List, Optional, Set, Tuple
 
 from ..errors import BoostError
 from . import frontmatter, gitutil, paths, registry, util
@@ -167,15 +167,49 @@ def rebuild_tap(tap: "registry.Tap") -> List[dict]:
         "commit": gitutil.head_commit(tap.path),
         "skills": entries,
     }, indent=1))
+    # Drop the mtime-keyed cache so a rebuild is visible to an immediately
+    # following load even when the filesystem mtime granularity is coarse.
+    _ENTRY_CACHE.pop(str(tap.cache_file), None)
     return entries
 
 
+# Entry-set cache, keyed on each tap cache file's (mtime_ns, size) stamp. The
+# BM25 index is mtime-cached the same way (rag._load_raw); without this, every
+# search reparses every tap cache. Entries are treated read-only by callers, so
+# the cached list is shared by reference (matching the index cache). Keying on
+# nanosecond mtime + size catches rewrites a bare second-resolution mtime would
+# miss.
+_ENTRY_CACHE: Dict[str, Tuple[Tuple[int, int], 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
+    key = str(p)
+    try:
+        st = p.stat()
+    except OSError:
+        _ENTRY_CACHE.pop(key, None)
+        return None
+    stamp = (st.st_mtime_ns, st.st_size)
+    cached = _ENTRY_CACHE.get(key)
+    if cached is not None and cached[0] == stamp:
+        return cached[1]
+    try:
+        skills = json.loads(p.read_text()).get("skills", [])
+    except (json.JSONDecodeError, OSError):
+        _ENTRY_CACHE.pop(key, None)
+        return None
+    _ENTRY_CACHE[key] = (stamp, skills)
+    return skills
+
+
 def load_tap(tap: "registry.Tap", rebuild: bool = False) -> List[dict]:
-    if not rebuild and tap.cache_file.exists():
-        try:
-            return json.loads(tap.cache_file.read_text()).get("skills", [])
-        except (json.JSONDecodeError, OSError):
-            pass
+    if not rebuild:
+        cached = _cached_tap(tap)
+        if cached is not None:
+            return cached
     if tap.is_cloned:
         return rebuild_tap(tap)
     return []

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/docs/roadmap/items/cache-the-catalog-entry-set-across-rag-queries.md

@@ -2,15 +2,15 @@
 id: cache-the-catalog-entry-set-across-rag-queries
 board: code
 section: internals
-status: planned
+status: shipped
 category: Performance
 complexity: M
 impact: Med
 wow: 3
 note: 
 order: 10
-owner:
-pr:
+owner: loop/cache-entry-set
+pr: 114
 title: Cache the catalog entry-set across RAG queries
 ---
 <code>rag.retrieve()</code> calls <code>all_entries()</code>, which reads &amp; <code>json.loads</code> <b>every tap cache on every search</b> to build the live map (<code>rag.py:323 · catalog.py:166–181</code>) — the BM25 index is mtime-cached, the entry set is not. Memoize the entry set on cache mtime the same way.

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/docs/roadmap/items/mcp-launch-objc-fork-safety.md

@@ -2,15 +2,15 @@
 id: mcp-launch-objc-fork-safety
 board: code
 section: compat
-status: planned
+status: shipped
 category: Compatibility · macOS
 complexity: S
 impact: Med
 wow: 3
 note: OBJC_DISABLE_INITIALIZE_FORK_SAFETY
 order: 9
-owner:
-pr:
+owner: loop/mcp-fork-safety
+pr: 119
 title: Harden <code>boost mcp</code> launch against macOS Obj-C fork aborts
 ---
 On macOS, a host that spawns <code>boost mcp --stdio</code> via <code>fork()</code>

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/docs/roadmap.html

@@ -548,7 +548,7 @@ by new unit tests covering every branch.</p>
       </article>
 
       <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Performance</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Performance</span></div>
         <h3>Cache the catalog entry-set across RAG queries</h3>
         <p><code>rag.retrieve()</code> calls <code>all_entries()</code>, which reads &amp; <code>json.loads</code> <b>every tap cache on every search</b> to build the live map (<code>rag.py:323 · catalog.py:166–181</code>) — the BM25 index is mtime-cached, the entry set is not. Memoize the entry set on cache mtime the same way.</p>
         <div class="meta">
@@ -1587,7 +1587,7 @@ and the work stays visible.</p>
       </article>
 
       <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Compatibility · macOS</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Compatibility · macOS</span></div>
         <h3>Harden <code>boost mcp</code> launch against macOS Obj-C fork aborts</h3>
         <p>On macOS, a host that spawns <code>boost mcp --stdio</code> via <code>fork()</code>
            can abort on the child side pre-<code>exec</code> when Obj-C is touched

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/tests/functional/test_cli_configuration.py

@@ -763,7 +763,9 @@ class TestMcp:
         shim = str(paths.repo_root() / "boost")
         r = boost("mcp", "register")
         assert "`claude` CLI not found — run this yourself:" in r.out
-        assert "claude mcp add --scope user boost -- %s mcp --stdio" % shim in r.out
+        assert ("claude mcp add --scope user "
+                "-e OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES -e no_proxy=* "
+                "boost -- %s mcp --stdio" % shim) in r.out
         r = boost("mcp", "unregister")
         assert "claude mcp remove boost" in r.out
         assert journal.events(action="mcp")[0]["subject"] == "unregister"
@@ -783,8 +785,10 @@ class TestMcp:
         monkeypatch.setattr("boost_cli.commands.configuration.subprocess.run",
                             fake_run)
         r = boost("mcp", "register")
-        assert calls == [["claude", "mcp", "add", "--scope", "user", "boost",
-                          "--", str(paths.repo_root() / "boost"),
+        assert calls == [["claude", "mcp", "add", "--scope", "user",
+                          "-e", "OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES",
+                          "-e", "no_proxy=*",
+                          "boost", "--", str(paths.repo_root() / "boost"),
                           "mcp", "--stdio"]]
         assert "Added stdio MCP server boost" in r.out
         assert "registered boost as an MCP server (scope: user)" in r.out

{boost_skill_cli-1.0.101 → boost_skill_cli-1.0.102}/tests/unit/test_catalog.py

@@ -345,6 +345,50 @@ class TestTapCaches:
         assert catalog.load_tap(registry.Tap(name="fake", url="")) == []
 
 
+class TestEntrySetCache:
+    """load_tap memoizes parsed skills on the cache file's (mtime_ns, size)
+    stamp, so repeated searches don't re-parse every tap cache."""
+
+    def test_unchanged_cache_returns_memoized_object(self, sandbox):
+        paths.ensure_dirs()
+        tap = registry.Tap(name="fake", url="")
+        tap.cache_file.write_text(json.dumps({"skills": [{"name": "s1"}]}))
+        first = catalog.load_tap(tap)
+        second = catalog.load_tap(tap)
+        # A cache hit returns the memoized list itself; a re-parse would build a
+        # fresh list, so identity proves the second call did not touch disk.
+        assert first == [{"name": "s1"}]
+        assert second is first
+
+    def test_content_change_invalidates_cache(self, sandbox):
+        paths.ensure_dirs()
+        tap = registry.Tap(name="fake", url="")
+        tap.cache_file.write_text(json.dumps({"skills": [{"name": "s1"}]}))
+        assert catalog.load_tap(tap) == [{"name": "s1"}]
+        # New content ⇒ different size ⇒ new stamp ⇒ the cache must re-read.
+        tap.cache_file.write_text(
+            json.dumps({"skills": [{"name": "s1"}, {"name": "s2"}]}))
+        assert catalog.load_tap(tap) == [{"name": "s1"}, {"name": "s2"}]
+
+    def test_rebuild_pops_stale_memo(self, sandbox, fixture_tap_src):
+        tap = registry.add(str(fixture_tap_src))
+        catalog.rebuild_tap(tap)          # write the cache file
+        catalog.load_tap(tap)             # read + memoize it
+        assert str(tap.cache_file) in catalog._ENTRY_CACHE
+        catalog.rebuild_tap(tap)          # must evict the now-stale memo
+        assert str(tap.cache_file) not in catalog._ENTRY_CACHE
+
+    def test_missing_cache_file_evicts_stamp(self, sandbox):
+        paths.ensure_dirs()
+        tap = registry.Tap(name="fake", url="")
+        tap.cache_file.write_text(json.dumps({"skills": [{"name": "s1"}]}))
+        assert catalog.load_tap(tap) == [{"name": "s1"}]
+        assert str(tap.cache_file) in catalog._ENTRY_CACHE
+        tap.cache_file.unlink()
+        assert catalog.load_tap(tap) == []  # no file, uncloned
+        assert str(tap.cache_file) not in catalog._ENTRY_CACHE
+
+
 class TestAllEntriesAndFind:
     def test_all_entries_config_order(self, sandbox):
         _fake_taps(