boost-skill-cli 1.0.418__tar.gz → 1.0.419__tar.gz

{boost_skill_cli-1.0.418/boost_skill_cli.egg-info → boost_skill_cli-1.0.419}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.418
+Version: 1.0.419
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -732,7 +732,7 @@ Windsurf, Cursor, and Gemini CLI** in a single pass.
 
 ```bash
 pipx install boost-skill-cli
-boost tap --defaults          # 5 curated registries
+boost tap --defaults          # 7 curated registries: skills, rules, workflows
 boost search tdd              # full-content BM25 over every skill
 boost install tdd-workflow    # → every agent, version-pinned, one lock file
 ```
@@ -776,7 +776,7 @@ Needs Python 3.12+ and `git`.
 ```bash
 pipx install boost-skill-cli        # or: pip install boost-skill-cli
 boost --version
-boost tap --defaults          # pull in the 5 starter registries
+boost tap --defaults          # pull in the 7 starter registries
 
 # upgrading later is `upgrade`, not `install --upgrade` — with a bare package
 # name the latter matches the spec you already satisfy and silently does nothing
@@ -958,14 +958,23 @@ just less cleverly.
 
 boost is itself an MCP server, so an agent can search and install skills mid-task
 instead of waiting for you to shell out. `boost mcp register` wires it into every
-agent CLI it finds on your PATH:
+agent CLI it finds on your PATH — and on a machine with no taps yet it also pulls
+in the starter registries first, so **installing boost and running `boost mcp` is
+the whole setup**:
 
 ```bash
 boost mcp register                 # every installed host (default: --host auto)
 boost mcp register --host gemini   # just one
+boost mcp register --no-seed       # register only; tap nothing
+boost mcp register --seed          # re-tap the defaults even if taps exist
 boost mcp unregister               # same host selection, in reverse
 ```
 
+The seed only fires when the catalog is empty — re-running `boost mcp` on a
+configured machine leaves your taps alone — and a failed clone is reported
+without taking the registration down with it. Export `BOOST_NO_SEED=1` to keep
+`boost mcp` a purely local operation (CI images, air-gapped machines).
+
 | Host | CLI | Registered in |
 |------|-----|---------------|
 | Claude Code | `claude` | `claude mcp add` → its user-scope MCP config |

{boost_skill_cli-1.0.418 → boost_skill_cli-1.0.419}/README.md

@@ -14,7 +14,7 @@ Windsurf, Cursor, and Gemini CLI** in a single pass.
 
 ```bash
 pipx install boost-skill-cli
-boost tap --defaults          # 5 curated registries
+boost tap --defaults          # 7 curated registries: skills, rules, workflows
 boost search tdd              # full-content BM25 over every skill
 boost install tdd-workflow    # → every agent, version-pinned, one lock file
 ```
@@ -58,7 +58,7 @@ Needs Python 3.12+ and `git`.
 ```bash
 pipx install boost-skill-cli        # or: pip install boost-skill-cli
 boost --version
-boost tap --defaults          # pull in the 5 starter registries
+boost tap --defaults          # pull in the 7 starter registries
 
 # upgrading later is `upgrade`, not `install --upgrade` — with a bare package
 # name the latter matches the spec you already satisfy and silently does nothing
@@ -240,14 +240,23 @@ just less cleverly.
 
 boost is itself an MCP server, so an agent can search and install skills mid-task
 instead of waiting for you to shell out. `boost mcp register` wires it into every
-agent CLI it finds on your PATH:
+agent CLI it finds on your PATH — and on a machine with no taps yet it also pulls
+in the starter registries first, so **installing boost and running `boost mcp` is
+the whole setup**:
 
 ```bash
 boost mcp register                 # every installed host (default: --host auto)
 boost mcp register --host gemini   # just one
+boost mcp register --no-seed       # register only; tap nothing
+boost mcp register --seed          # re-tap the defaults even if taps exist
 boost mcp unregister               # same host selection, in reverse
 ```
 
+The seed only fires when the catalog is empty — re-running `boost mcp` on a
+configured machine leaves your taps alone — and a failed clone is reported
+without taking the registration down with it. Export `BOOST_NO_SEED=1` to keep
+`boost mcp` a purely local operation (CI images, air-gapped machines).
+
 | Host | CLI | Registered in |
 |------|-----|---------------|
 | Claude Code | `claude` | `claude mcp add` → its user-scope MCP config |

{boost_skill_cli-1.0.418 → boost_skill_cli-1.0.419}/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.418'
-__version_tuple__ = version_tuple = (1, 0, 418)
+__version__ = version = '1.0.419'
+__version_tuple__ = version_tuple = (1, 0, 419)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.418 → boost_skill_cli-1.0.419}/boost_cli/commands/configuration.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from .. import __version__, cliparse
 from ..core import (
     agents,
+    bootstrap,
     catalog,
     complete,
     config,
@@ -877,23 +878,23 @@ def _tool_search(args: dict):
     # the asymmetry with the CLI is a decision someone can revisit, not a
     # default nobody chose. It degrades on its own when no AI is configured.
     rag_result = rag.search(query, limit=10, smart=True)
+    # Both empty branches route through mcp.no_results, which tells a real
+    # miss apart from a machine that has never been tapped — the two used to
+    # share one sentence, and the fresh-install case is the one an agent reads
+    # first and learns the most from.
+    tapped = len(registry.list_taps())
     if rag_result is not None:  # full-content index is built
         hits, ranker = rag_result
         if not hits:
-            return "no skills match %r" % query, False
-        lines = [
-            "%s — %s (%s)" % (h["entry"]["name"],
-                              h["entry"].get("description", ""),
-                              h["entry"]["tap"])
-            for h in hits]
+            return mcp.no_results(query, tapped=tapped), False
+        lines = [mcp.hit_line(h["entry"]) for h in hits]
         lines.append(_ranking_note(ranker))
         return "\n".join(lines), False
     # no index yet -> keep today's frontmatter search so nothing regresses
     scored = catalog.search(query)[:10]
     if not scored:
-        return "no skills match %r" % query, False
-    return "\n".join("%s — %s (%s)" % (e["name"], e["description"], e["tap"])
-                     for e, _score in scored), False
+        return mcp.no_results(query, tapped=tapped), False
+    return "\n".join(mcp.hit_line(e) for e, _score in scored), False
 
 
 def _tool_list(args: dict):
@@ -987,7 +988,10 @@ def _tool_doctor(args: dict):
     lines = ["installed skills: %d" % len(everything["skill"]),
              "installed rules: %d · workflows: %d"
              % (len(everything["rule"]), len(everything["workflow"])),
-             "taps: %d (%d skills available)" % (len(taps), len(catalog.all_entries()))]
+             # "items", not "skills": the default taps now carry rules and
+             # workflows too, so counting all of them as skills overstates one
+             # kind and hides the other two in the same breath.
+             "taps: %d (%d items available)" % (len(taps), len(catalog.all_entries()))]
     for key, vals in plan.items():
         if vals:
             lines.append("%s: %s" % (key, ", ".join(str(v) for v in vals)))
@@ -1000,8 +1004,26 @@ def _tool_doctor(args: dict):
                       == integrity.STATUS_MODIFIED)]
     lines.extend(mat_issues)
     total = issues + len(mat_issues)
+    # A machine with no taps has nothing to disagree about, so every check
+    # above passes and the old reply called it "healthy" — directly under the
+    # line saying `taps: 0 (0 items available)`. That is the one state where
+    # a clean bill of health is actively misleading: the surface cannot answer
+    # anything yet, which is a setup step, not health. Reported, never fatal.
+    # Additive, deliberately: an untapped machine can ALSO have a broken
+    # materialization, and folding the two into one branch would hide the
+    # issue count behind the setup note.
+    if not taps:
+        # Same command, same order, as mcp.no_results: an agent that calls
+        # both tools in one session must not see the recommendation flipped
+        # and read it as two different fixes. `boost tap --defaults` leads
+        # because it is the precise one — `boost mcp --seed` also
+        # re-registers the server with every agent CLI on PATH.
+        lines.append("no registries tapped — nothing is searchable yet; ask "
+                     "the user to run `boost tap --defaults` to add the "
+                     "recommended ones")
     if total == 0:
-        lines.append("healthy — no issues found")
+        if taps:
+            lines.append("healthy — no issues found")
     elif mat_issues:
         lines.append("%d issue(s) — run `boost doctor` for details" % total)
     else:
@@ -1045,12 +1067,19 @@ def _tool_discover_github(args: dict):
 REGISTRY.register(
     "boost_search",
     "Someone has probably solved this already — one call tells you. Searches "
-    "every installable AI-agent skill in every registry you have "
-    "tapped and returns ranked matches: each one a procedure a "
-    "practitioner already worked out, debugged and wrote down, edge cases "
-    "included. Reach for it the moment the task in front of you has a name you "
+    "every skill, rule and workflow in every registry you have tapped and "
+    "returns ranked matches, one per line: name, a [rule] or [workflow] kind "
+    "marker where it is not a skill, the one-line description, and the tap it "
+    "came from. The kinds differ in what they do for you — a SKILL is a "
+    "procedure a practitioner already worked out and debugged, edge cases "
+    "included; a RULE is a guardrail that steers toward a better path and "
+    "rules out an anti-pattern; a WORKFLOW is a slash-command or subagent. "
+    "Reach for it the moment the task in front of you has a name you "
     "could say out loud — \"set up code review\", \"add commit conventions\", "
-    "\"debug flaky tests\" — and before writing a skill, subagent, "
+    "\"debug flaky tests\" — and especially where a choice is about to get "
+    "locked in for everything after it: a new project or subsystem, an "
+    "architecture decision, environment and tooling config, a linter or "
+    "formatter, tests, CI. Also before writing a skill, subagent, "
     "slash-command or rule from scratch. Read-only where it counts: it "
     "installs nothing and touches nothing you are working on, though the first "
     "search builds a local index under ~/.boost. A hit commits you to nothing "
@@ -1059,32 +1088,41 @@ REGISTRY.register(
     "result worth acting on rather than skimming. Worth budgeting for, not a "
     "surprise. Coming back empty is a real answer too, not a "
     "wasted turn: it means build it yourself, now knowing nothing already "
-    "covers it.",
+    "covers it — and on a machine with nothing tapped yet it says so and names "
+    "the one command that fixes it, rather than reporting a miss.",
     {"type": "object",
      "properties": {"query": {"type": "string",
-                              "description": "what the skill should do (a task, "
-                              "capability, or topic), not just a keyword"}},
+                              "description": "what you are trying to do, in "
+                              "your own words — a task, capability or problem "
+                              "(\"set up pre-commit hooks for a python repo\") "
+                              "rather than a bare keyword"}},
      "required": ["query"]},
     _tool_search)
 REGISTRY.register(
     "boost_list",
-    "The skills already installed on this machine and usable this second — "
-    "capability you own and may not know you own. Read-only, instant, installs "
-    "nothing. Worth a call at the start of "
-    "anything that will take more than a few steps: planning from memory while "
+    "The skills, rules and workflows already installed on this machine and "
+    "usable this second — capability you own and may not know you own. "
+    "Returns one line each: name, version, tap, a [rule] or [workflow] marker "
+    "where it is not a skill, and [pinned] where the version is held. "
+    "Read-only, instant, installs nothing — so unlike boost_search there is "
+    "no threshold worth applying: call it whenever you are about to plan "
+    "something. Planning from memory while "
     "the answer already sits on disk is the one avoidable mistake here.",
     {"type": "object", "properties": {}},
     _tool_list)
 REGISTRY.register(
     "boost_info",
-    "The whole picture of one skill by name — what it does, the tap it came "
+    "The whole picture of one skill, rule or workflow by name — what it does, "
+    "its kind, the tap it came "
     "from, its version, and whether it is already installed — so you can "
     "commit or move on without guessing. Reach for it when a name arrives from "
     "somewhere else: a teammate, a README, a repo you are reading. You do not "
     "need this between a search and an install — boost_search already returns "
-    "each match's description.",
+    "each match's kind and description.",
     {"type": "object",
-     "properties": {"name": {"type": "string", "description": "skill name"}},
+     "properties": {"name": {"type": "string",
+                             "description": "the item's name, as boost_search "
+                             "or boost_list returned it"}},
      "required": ["name"]},
     _tool_info)
 REGISTRY.register(
@@ -1096,18 +1134,29 @@ REGISTRY.register(
     "a prompt, which lasts one "
     "session and helps nobody else: an installed skill is version-tracked, "
     "survives restarts, updates cleanly, and your team can install the "
-    "identical thing by name. Worth knowing before you call it: boost_search "
-    "also returns rules, and installing a rule copies nothing into the store — "
-    "it merges into the context file your agent loads every session, which is "
-    "the more invasive change. Check what kind of thing you are installing.",
+    "identical thing by name. Worth knowing before you call it: what happens "
+    "on disk depends on the kind, which boost_search marks on every hit. A "
+    "skill is copied into the store and linked out. A WORKFLOW is rendered "
+    "into each agent's commands or agents directory, in that agent's own "
+    "format. A RULE copies nothing into the store — it becomes part of your "
+    "agent's standing instructions (a managed block in its context file, or a "
+    "file in its rules directory), which is the more invasive change because "
+    "it applies to every session afterwards, not just when you reach for it. "
+    "Check the marker on the hit you are installing.",
     {"type": "object",
-     "properties": {"name": {"type": "string", "description": "skill name"}},
+     "properties": {"name": {"type": "string",
+                             "description": "the name exactly as boost_search "
+                             "or boost_list returned it; qualify with the tap "
+                             "(\"owner/repo:name\") when the same name exists "
+                             "in more than one"}},
      "required": ["name"]},
     _tool_install)
 REGISTRY.register(
     "boost_doctor",
     "Prove the skills you think are installed are actually usable. Reports how "
-    "many skills are installed, how many taps and skills are reachable, and "
+    "many skills, rules and workflows are installed, how many taps and items "
+    "are reachable (including the case where nothing is tapped at all, which "
+    "is a setup step rather than a fault), and "
     "anything the store and the lock file disagree about — and when they do "
     "disagree it points at the next action, `boost sync` — though some classes "
     "need `boost sync --prune` — rather than leaving you a "
@@ -1170,8 +1219,39 @@ def _run_mcp_host(host: str, action: str, cmd) -> bool:
     return True
 
 
+def _seed_catalog_for_mcp(force: bool) -> None:
+    """Tap the recommended registries so the surface just registered can answer.
+
+    `boost mcp` is the only command a new user is told to run after installing,
+    and it used to leave them with a registered server over an empty catalog —
+    where the first thing any agent asks comes back as a miss. Seeding here is
+    what makes "install boost, run boost mcp" the whole setup.
+
+    Deliberately quiet on an already-tapped machine (see bootstrap.seed_catalog:
+    it returns skipped), and deliberately non-fatal — the user asked to register
+    an MCP server, so a dead network costs them a reported line rather than the
+    registration itself.
+    """
+    # Announced before the clones start, because the loop that follows is
+    # 14-45s of network with nothing to show for it until it finishes — on
+    # the one command a first-time user was told to run, silence that long
+    # reads as a hang.
+    if bootstrap.will_seed(force=force):
+        out.info("no registries tapped yet — adding the %d recommended ones "
+                 "(one-time, needs the network)" % len(config.DEFAULT_TAPS))
+    res = bootstrap.seed_catalog(force=force)
+    if res.skipped:
+        return
+    for line in res.failed:
+        out.warn("could not tap %s" % line)
+    if res.tapped:
+        out.ok(res.summary())
+    else:
+        out.warn(res.summary())
+
+
 def cmd_mcp(argv) -> int:
-    """boost mcp [register|unregister] [--host H] [--stdio]"""
+    """boost mcp [register|unregister] [--host H] [--stdio] [--seed|--no-seed]"""
     p = cliparse.parser(
         prog="boost mcp",
         description="Register boost as an MCP server for your agent CLIs")
@@ -1184,6 +1264,16 @@ def cmd_mcp(argv) -> int:
                         % ", ".join(mcphost.hosts()))
     p.add_argument("--stdio", action="store_true",
                    help="run the MCP server on stdin/stdout (used by the agent)")
+    # Mutually exclusive: `--seed --no-seed` used to resolve silently to the
+    # network-touching side, which is the wrong way for an ambiguous pair of
+    # explicitly typed flags to break.
+    seeding = p.add_mutually_exclusive_group()
+    seeding.add_argument("--seed", action="store_true",
+                         help="top up any missing recommended registries even "
+                              "if others are already tapped (the repair path)")
+    seeding.add_argument("--no-seed", dest="seed_ok", action="store_false",
+                         default=True,
+                         help="register only; do not tap anything")
     args = p.parse_args(argv)
 
     if args.stdio:
@@ -1195,6 +1285,14 @@ def cmd_mcp(argv) -> int:
         raise BoostError("unknown MCP host %r" % args.host,
                         hint="known hosts: %s" % ", ".join(mcphost.hosts())) from e
 
+    # After the host name is validated and before anything is registered. The
+    # ordering is not cosmetic in either direction: seeding first meant a
+    # typo'd `--host` spent 14-45s and half a gigabyte before argparse's own
+    # error, and seeding last would have registered a server the user then
+    # watches answer nothing while the clones run.
+    if args.action == "register" and (args.seed_ok or args.seed):
+        _seed_catalog_for_mcp(args.seed)
+
     shim = str(paths.launcher())
     # `auto` skips hosts that are not installed; naming a host explicitly (or
     # `all`) always reports it, so a user setting up a machine can see the argv

{boost_skill_cli-1.0.418 → boost_skill_cli-1.0.419}/boost_cli/commands/taps.py

@@ -119,14 +119,17 @@ def cmd_tap(argv) -> int:
                 rc = 1
                 continue
             journal.log("tap", tap.name)
-            out.ok("tapped %s (%d skills) — %s"
+            # "items", not "skills": the defaults now carry rules and
+            # workflows, so a pure rules registry reported "257 skills"
+            # immediately after the README promised three kinds.
+            out.ok("tapped %s (%d items) — %s"
                    % (tap.name, len(entries), default.get("focus", "")))
     if args.spec:
         with spin.Spinner("cloning %s" % args.spec):
             tap = registry.add(args.spec, curated=args.curated)
             entries = catalog.rebuild_tap(tap)
         journal.log("tap", tap.name)
-        out.ok("Tapped %s (%d skills)" % (tap.name, len(entries)))
+        out.ok("Tapped %s (%d items)" % (tap.name, len(entries)))
     # Refresh the TAB-completion name cache so `boost install <TAB>` sees
     # whatever this call just tapped instead of the pre-tap snapshot.
     complete.refresh_names()

boost_skill_cli-1.0.419/boost_cli/core/bootstrap.py

@@ -0,0 +1,135 @@
+"""Seed an empty machine's catalog, so one command is the whole setup.
+
+`boost mcp` is the only command a new user is told to run after installing.
+It registered the server and stopped there — against a catalog with nothing in
+it — so the first question any agent asked came back as a miss, which is the
+fastest possible way to teach an agent that boost is not worth asking again.
+
+Seeding belongs here rather than in the command layer for the usual reason:
+it is behavior with rules worth pinning (idempotent, never fatal, reports what
+it did), and `boost_cli/core` is what the mutation gate targets.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+from ..errors import BoostError
+from . import catalog, config, journal, registry
+
+#: Escape hatch, same shape as ``BOOST_NO_MCP_OFFER``: suppress the implicit
+#: seed for anyone who wants `boost mcp` to stay a local, offline operation —
+#: CI images, air-gapped machines, and the test suite, which must never clone
+#: seven repositories to check that registration prints the right line. An
+#: explicit ``--seed`` still wins over it: a flag the user typed outranks an
+#: environment default they may not know is set.
+NO_SEED_ENV = "BOOST_NO_SEED"
+
+
+@dataclass
+class SeedResult:
+    """What a seed attempt did, in terms a caller can print."""
+
+    #: (tap name, item count) for each registry that landed.
+    tapped: list[tuple[str, int]] = field(default_factory=list)
+    #: One human-readable line per registry that could not be fetched.
+    failed: list[str] = field(default_factory=list)
+    #: Defaults that were already configured, so nothing was done for them.
+    already: list[str] = field(default_factory=list)
+    #: True when nothing was attempted at all (opted out, or already complete).
+    skipped: bool = False
+
+    @property
+    def item_count(self) -> int:
+        """Total catalog items across every registry this call added."""
+        return sum(count for _name, count in self.tapped)
+
+    def summary(self) -> str:
+        """One line for the user: what is now searchable, or why nothing is."""
+        if self.skipped:
+            return "catalog already tapped — leaving it alone"
+        if not self.tapped:
+            # Only claim the network is the problem when the network was
+            # actually the problem. A run where every default was already
+            # configured reaches here too, and telling that user to retry
+            # "once you have a network" is advice about a machine they do
+            # not have — see the `--seed` repair path, which hits it head-on.
+            if self.failed:
+                return ("could not reach any default registry — run "
+                        "`boost tap --defaults` once you have a network")
+            return "catalog already tapped — leaving it alone"
+        line = ("tapped %d registries (%d items searchable)"
+                % (len(self.tapped), self.item_count))
+        if self.already:
+            line += " — %d already tapped" % len(self.already)
+        if self.failed:
+            line += " — %d could not be fetched" % len(self.failed)
+        return line
+
+
+def will_seed(*, force: bool = False) -> bool:
+    """True when :func:`seed_catalog` would actually clone something.
+
+    Exists so a caller can announce the wait BEFORE it starts. The seed is
+    14-45s of network with nothing to print until it returns, and on the one
+    command a first-time user was told to run, silence that long reads as a
+    hang. Deliberately mirrors seed_catalog's own gates rather than guessing.
+    """
+    if not force and os.environ.get(NO_SEED_ENV):
+        return False
+    existing = {t.name for t in registry.list_taps()}
+    if not force and existing:
+        return False
+    return any(str(d["name"]) not in existing for d in config.DEFAULT_TAPS)
+
+
+def seed_catalog(*, force: bool = False) -> SeedResult:
+    """Tap whichever recommended registries this machine is missing.
+
+    The decision is per registry, not per machine, and that distinction is
+    load-bearing twice over. A seed interrupted after two clones used to leave
+    a machine that read as "configured" forever, because the check was "does
+    ANY tap exist" — so the remaining five never arrived and nothing ever said
+    so. And `--seed`, documented as the repair path, called ``registry.add``
+    on registries that were already there; ``add`` rejects those before it
+    touches the network, so the repair reported seven failures and blamed the
+    connection on a machine whose connection was fine.
+
+    Skips silently when the user opted out (``BOOST_NO_SEED``) or when every
+    default is already present. Never raises: this runs on the registration
+    path, where the user's actual request was "register the MCP server" — a
+    dead network or one bad remote must cost them a reported line, not the
+    server they asked for.
+    """
+    if not force and os.environ.get(NO_SEED_ENV):
+        return SeedResult(skipped=True)
+    existing = {t.name for t in registry.list_taps()}
+    # `force` re-checks the DEFAULTS rather than re-adding them: a machine
+    # missing two of seven is topped up, and one missing none is left alone.
+    missing = [d for d in config.DEFAULT_TAPS if str(d["name"]) not in existing]
+    if not missing:
+        return SeedResult(skipped=True)
+    # Without --seed the implicit path stays conservative: a machine with taps
+    # of its own is somebody's configured setup, and quietly adding seven
+    # registries to it because they re-ran `boost mcp` is boost editing state
+    # it was not asked to touch.
+    if not force and existing:
+        return SeedResult(skipped=True)
+    res = SeedResult(already=[str(d["name"]) for d in config.DEFAULT_TAPS
+                              if str(d["name"]) in existing])
+    for default in missing:
+        name = str(default["name"])
+        try:
+            tap = registry.add(str(default["url"]), curated=True)
+            entries = catalog.rebuild_tap(tap)
+        except BoostError as e:
+            res.failed.append("%s: %s" % (name, e.message))
+            continue
+        except OSError as e:
+            # A clone can fail below BoostError (disk full, permissions).
+            # Same contract: report it, keep going, never take the caller down.
+            res.failed.append("%s: %s" % (name, e))
+            continue
+        journal.log("tap", tap.name)
+        res.tapped.append((tap.name, len(entries)))
+    return res

{boost_skill_cli-1.0.418 → boost_skill_cli-1.0.419}/boost_cli/core/config.py

@@ -51,7 +51,18 @@ DEFAULTS = {
     },
 }
 
-# Recommended public registries, added via `boost tap --defaults`.
+# Recommended public registries, added via `boost tap --defaults` and by the
+# seed that runs on `boost mcp` (core/bootstrap.py) so one command is the
+# whole setup.
+#
+# The list covers all THREE item kinds on purpose. The five skills-first repos
+# measured 302 skills and 41 workflows between them and — the gap this closes
+# — zero rules, so the kind whose entire job is steering toward a better path
+# and away from an anti-pattern could not be found by a default install at
+# all. Adding one canonical rules repo and one commands/agents repo takes the
+# default corpus to 946 items (302 skills, 387 workflows, 257 rules) for about
+# 14 MB more on disk than the five, measured end-to-end at 14-45s across runs
+# (network-bound, hence the range).
 DEFAULT_TAPS = [
     {"name": "anthropics/skills", "url": "https://github.com/anthropics/skills",
      "curated": True,
@@ -69,6 +80,16 @@ DEFAULT_TAPS = [
      "url": "https://github.com/K-Dense-AI/scientific-agent-skills",
      "curated": True,
      "focus": "Scientific computing — research libraries, databases, analysis"},
+    {"name": "PatrickJS/awesome-cursorrules",
+     "url": "https://github.com/PatrickJS/awesome-cursorrules",
+     "curated": True,
+     "focus": "Rules — the canonical .cursorrules/.mdc collection: per-stack "
+              "conventions and anti-patterns to avoid"},
+    {"name": "qdhenry/Claude-Command-Suite",
+     "url": "https://github.com/qdhenry/Claude-Command-Suite",
+     "curated": True,
+     "focus": "Workflows — slash commands and subagents for review, testing, "
+              "refactoring and release"},
 ]