boost-skill-cli 1.0.181__tar.gz → 1.0.183__tar.gz

boost_skill_cli-1.0.183/.vale/styles/boost/Terminology.yml

@@ -0,0 +1,17 @@
+extends: substitution
+message: "Use '%s' instead of '%s'."
+level: error
+ignorecase: false
+# Canonical casing for names that appear in boost's prose. Scope is text only —
+# Vale never looks inside code spans or fences, so `github.com/...` URLs and
+# shell examples are unaffected.
+swap:
+  '\bGithub\b': GitHub
+  '\bgithub\b(?!\.com)': GitHub
+  '\bPypi\b': PyPI
+  '\bpypi\b(?!\.org)': PyPI
+  '\bMacos\b': macOS
+  '\bMacOS\b': macOS
+  '\bCrewai\b': CrewAI
+  '\bLanggraph\b': LangGraph
+  '\bjavascript\b': JavaScript

boost_skill_cli-1.0.183/.vale/styles/config/vocabularies/boost/accept.txt

@@ -0,0 +1,72 @@
+agentic
+allowlisted
+argparse
+bmad
+bookended
+CI's
+codespell
+config
+configs
+cyclomatic
+Dependabot
+deps
+Dev
+docsite
+DSPy
+else's
+env
+evals
+freemium
+frontmatter
+gitignored
+glassmorphic
+hardcode
+jonnyeclectic
+jonnyeclectic's
+langchain
+lowercasing
+mcp
+mergeable
+mutmut
+mypy
+npm
+Pinecone
+pytest
+rebased
+reindex
+repo
+repo's
+repos
+rerank
+Rerank
+reranking
+ruleset
+rulesets
+Rulesets
+sandboxed
+sandboxing
+stderr
+Stdlib
+stdlib
+stdout
+subagents
+subcommand
+teardown
+tempdir
+toggleable
+Tokenization
+tokenization
+toolkits
+traceback
+tracebacks
+unkilled
+unstaged
+untap
+venv
+venvs
+Weaviate
+webfont
+wordmark
+worktree
+worktrees
+zsh

boost_skill_cli-1.0.183/.vale.ini

@@ -0,0 +1,24 @@
+; Vale — prose & terminology linting for the contributor-facing Markdown
+; surfaces (the same set markdownlint covers). Two things are enforced:
+;   1. Vale.Spelling with the boost vocabulary (.vale/styles/config/
+;      vocabularies/boost/accept.txt) — catches future typos codespell's
+;      dictionary misses, without nagging on the project's technical terms.
+;   2. boost.Terminology — canonical casing for product names (GitHub, PyPI,
+;      macOS, ...) in prose. Code spans and fences are never checked.
+; Run locally:  vale README.md CONTRIBUTING.md docs/*.md
+StylesPath = .vale/styles
+MinAlertLevel = warning
+Vocab = boost
+
+[*.md]
+BasedOnStyles = Vale, boost
+; accept.txt is a spelling allowlist, not canonical casing — MCP vs mcp both fine.
+Vale.Terms = NO
+
+; Roadmap card bodies are HTML-in-Markdown copy rendered by build_roadmap.py,
+; and .claude/ is agent-harness config — neither is standalone prose.
+[docs/roadmap/items/*.md]
+BasedOnStyles =
+
+[.claude/**/*.md]
+BasedOnStyles =

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/Makefile

@@ -14,7 +14,7 @@ EVAL_HOME := $(CURDIR)/.eval-home
 
 venv:
 	python3 -m venv $(VENV)
-	$(VENV)/bin/pip -q install pytest pytest-cov coverage mutmut ruff mypy codespell hypothesis import-linter diff-cover vulture xenon pyright
+	$(VENV)/bin/pip -q install pytest pytest-cov coverage mutmut ruff mypy codespell hypothesis import-linter diff-cover vulture xenon pyright interrogate
 
 unit:
 	$(PYTEST) tests/unit -q
@@ -49,6 +49,7 @@ lint:
 	$(VENV)/bin/lint-imports
 	$(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/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.181 → boost_skill_cli-1.0.183}/PKG-INFO

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

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/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.181'
-__version_tuple__ = version_tuple = (1, 0, 181)
+__version__ = version = '1.0.183'
+__version_tuple__ = version_tuple = (1, 0, 183)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/agents.py

@@ -21,13 +21,16 @@ def known_agents() -> Dict[str, dict]:
 
 
 def enabled_agents() -> Dict[str, Path]:
+    """{name: dir Path} for just the agents whose "enabled" flag is true."""
     return {n: s["dir"] for n, s in known_agents().items() if s["enabled"]}
 
 
 def display_name(agent: str) -> str:
+    """`claude-code` -> "Claude Code"; unknown names pass through unchanged."""
     return DISPLAY.get(agent, agent)
 
 
 def ensure_agent_dirs() -> None:
+    """Create every enabled agent's skills dir (`mkdir -p`, idempotent)."""
     for d in enabled_agents().values():
         d.mkdir(parents=True, exist_ok=True)

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/ai.py

@@ -20,18 +20,25 @@ API_URL = "https://api.anthropic.com/v1/messages"
 
 
 def enabled() -> bool:
+    """Return True when `ai.enabled` is on and BOOST_NO_AI is unset."""
     return bool(config.get("ai.enabled", True)) and not os.environ.get("BOOST_NO_AI")
 
 
 def available() -> bool:
+    """Return True when AI is enabled and a backend exists: the `claude`
+
+    CLI on PATH or ANTHROPIC_API_KEY set.
+    """
     return enabled() and (has_cli() or bool(os.environ.get("ANTHROPIC_API_KEY")))
 
 
 def has_cli() -> bool:
+    """Return True when the `claude` CLI is on PATH."""
     return shutil.which("claude") is not None
 
 
 def fallback_note() -> str:
+    """Return the one-line hint shown when a command degrades to heuristics."""
     return ("AI features need the `claude` CLI on PATH or ANTHROPIC_API_KEY set "
             "— using the heuristic fallback")
 

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/catalog.py

@@ -102,6 +102,11 @@ def _classify_workflow(path: Path, meta: dict) -> bool:
 
 
 def scan_dir(root: Path, tap_name: str = "local", curated: bool = False) -> List[dict]:
+    """Walk `root` and index every skill/rule/workflow into entry dicts.
+
+    Files inside a SKILL.md dir belong to that skill, never re-indexed;
+    output is sorted by (skill_md, name) regardless of walk order.
+    """
     root = Path(root)
     entries: List[dict] = []
     skill_dirs: Set[Path] = set()
@@ -155,6 +160,11 @@ def scan_dir(root: Path, tap_name: str = "local", curated: bool = False) -> List
 
 
 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
+    in-process entry cache so an immediate load sees the rebuild.
+    """
     if not tap.is_cloned:
         raise BoostError("tap %s is not cloned" % tap.name,
                         hint="run `boost update %s`" % tap.name)
@@ -206,6 +216,11 @@ def _cached_tap(tap: "registry.Tap") -> Optional[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
+    uncloned tap yields `[]`.
+    """
     if not rebuild:
         cached = _cached_tap(tap)
         if cached is not None:
@@ -216,6 +231,7 @@ def load_tap(tap: "registry.Tap", rebuild: bool = False) -> List[dict]:
 
 
 def all_entries() -> List[dict]:
+    """Return the entries of every configured tap, concatenated."""
     out: List[dict] = []
     for tap in registry.list_taps():
         out.extend(load_tap(tap))

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/config.py

@@ -124,18 +124,25 @@ def _cached() -> dict:
 
 
 def load() -> dict:
+    """Return a deep copy of the merged config, safe for callers to mutate."""
     # A defensive copy so callers can mutate the result (set_value/unset do)
     # without corrupting the shared cache.
     return deepcopy(_cached())
 
 
 def save(cfg: dict) -> None:
+    """Atomically write `cfg` to `~/.boost/config.json`, creating dirs first."""
     paths.ensure_dirs()
     util.atomic_write_text(
         paths.config_path(), json.dumps(cfg, indent=2, sort_keys=False) + "\n")
 
 
 def get(dotted: str, default=None):
+    """Look up a dotted key (`ai.model`) in the merged config.
+
+    
+    Returns a deep copy of the value, or `default` if any part is missing.
+    """
     node = _cached()
     for part in dotted.split("."):
         if not isinstance(node, dict) or part not in node:
@@ -162,6 +169,7 @@ def set_value(dotted: str, raw: str) -> None:
 
 
 def unset(dotted: str) -> bool:
+    """Delete a dotted key and save; True if removed, False (no write) if absent."""
     cfg = load()
     node: Any = cfg
     parts = dotted.split(".")

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/dense.py

@@ -35,10 +35,12 @@ def _load():
 
 
 def have_backend() -> bool:
+    """True when the ``sqlite-vec`` backend (the ``[rag]`` extra) imports."""
     return _load() is not None
 
 
 def db_path() -> Path:
+    """Path of the vector store: ``rag_vectors.sqlite`` in the cache dir."""
     return paths.cache_dir() / "rag_vectors.sqlite"
 
 

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/embed.py

@@ -29,6 +29,7 @@ _DIMS = {VOYAGE_MODEL: 1024, OPENAI_MODEL: 1536}
 
 
 def enabled() -> bool:
+    """True unless the ``BOOST_NO_EMBED`` kill-switch is set."""
     return not os.environ.get("BOOST_NO_EMBED")
 
 
@@ -44,10 +45,12 @@ def provider() -> Optional[str]:
 
 
 def available() -> bool:
+    """True when embeddings are enabled and a provider key is present."""
     return provider() is not None
 
 
 def model() -> Optional[str]:
+    """The active provider's model name, or None when unconfigured."""
     p = provider()
     if p == "voyage":
         return VOYAGE_MODEL
@@ -57,11 +60,16 @@ def model() -> Optional[str]:
 
 
 def dimension() -> Optional[int]:
+    """Output vector dimension of the active model, or None when
+
+    unconfigured. Stored in the index so a model switch forces a rebuild.
+    """
     m = model()
     return _DIMS.get(m) if m is not None else None
 
 
 def fallback_note() -> str:
+    """The one-line hint shown when dense search degrades to BM25."""
     return ("dense search needs the `rag` extra and VOYAGE_API_KEY or "
             "OPENAI_API_KEY — using the BM25 full-content engine")
 

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/gitutil.py

@@ -10,11 +10,17 @@ from ..errors import BoostError
 
 
 def has_git() -> bool:
+    """Return True when a `git` executable is on PATH."""
     return shutil.which("git") is not None
 
 
 def run(args: List[str], cwd: Optional[Path] = None, check: bool = True,
         timeout: int = 300) -> subprocess.CompletedProcess:
+    """Run `git *args` with captured text output; return the CompletedProcess.
+
+    Raises BoostError if git is missing, on timeout, or (when `check`)
+    on nonzero exit.
+    """
     if not has_git():
         raise BoostError("git is required but was not found on PATH",
                         hint="install git, e.g. `xcode-select --install` or `brew install git`")
@@ -38,6 +44,10 @@ _UNSAFE_TRANSPORTS = ("ext::", "file::", "fd::")
 
 
 def clone_shallow(url: str, dest: Path) -> None:
+    """Shallow-clone (`--depth 1`) `url` into `dest`, creating parent dirs.
+
+    Raises BoostError for unsafe remote-helper transports like `ext::`.
+    """
     if url.lstrip().lower().startswith(_UNSAFE_TRANSPORTS):
         raise BoostError(
             "refusing to clone via unsafe git transport: %s" % url,
@@ -61,11 +71,13 @@ def pull(repo: Path) -> str:
 
 
 def head_commit(repo: Path) -> str:
+    """Return the full HEAD commit hash of `repo`, or "" if unresolvable."""
     proc = run(["-C", str(repo), "rev-parse", "HEAD"], check=False)
     return proc.stdout.strip() if proc.returncode == 0 else ""
 
 
 def remote_url(repo: Path) -> str:
+    """Return the URL of `repo`'s `origin` remote, or "" if it has none."""
     proc = run(["-C", str(repo), "remote", "get-url", "origin"], check=False)
     return proc.stdout.strip() if proc.returncode == 0 else ""
 
@@ -78,4 +90,5 @@ def log_for_path(repo: Path, rel_path: str = ".", n: int = 20) -> List[str]:
 
 
 def is_repo(path: Path) -> bool:
+    """Return True when `path` contains a `.git` entry."""
     return (Path(path) / ".git").exists()

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/injectscan.py

@@ -23,6 +23,11 @@ _SEVERITY_RANK = {"high": 3, "medium": 2, "low": 1}
 
 
 class Rule(NamedTuple):
+    """One curated detection pattern applied per line of scanned text.
+
+    ``id`` is stable for callers/tests to key on; ``severity`` is one
+    of "high", "medium", or "low".
+    """
     id: str
     severity: str
     pattern: "re.Pattern[str]"
@@ -30,6 +35,10 @@ class Rule(NamedTuple):
 
 
 class Finding(NamedTuple):
+    """One rule match on one line of scanned text.
+
+    ``line`` is 1-based; ``snippet`` is the offending line, trimmed.
+    """
     rule_id: str
     severity: str
     line: int          # 1-based line number the pattern matched on

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/journal.py

@@ -14,6 +14,10 @@ ROTATE_KEEP = 2500
 
 
 def log(action: str, subject: str = "", **fields) -> None:
+    """Append one event line to the pulse feed, rotating when oversized.
+
+    None-valued keyword fields are dropped from the record.
+    """
     paths.ensure_dirs()
     event = {"ts": util.now_iso(), "user": util.user(), "action": action,
              "subject": subject}
@@ -46,6 +50,7 @@ def events(n: Optional[int] = None, action: Optional[str] = None,
 
 
 def rotation_healthy() -> bool:
+    """True when the pulse feed is absent or at most ROTATE_AT lines long."""
     p = paths.pulse_path()
     if not p.exists():
         return True

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/lockfile.py

@@ -25,6 +25,11 @@ def _skeleton() -> dict:
 
 
 def read() -> dict:
+    """Load the lock file, guaranteeing skills/rules/workflows keys.
+
+    Missing file -> empty skeleton; a corrupt file is preserved as
+    ``<lock>.corrupt`` before falling back to the skeleton.
+    """
     p = paths.lockfile_path()
     if not p.exists():
         return _skeleton()          # empty: never installed anything yet
@@ -65,6 +70,11 @@ def _preserve_corrupt(p) -> None:
 
 
 def write(lock: dict) -> None:
+    """Snapshot the existing lock to history, then write ``lock`` atomically.
+
+    Stamps ``version``/``updated`` on ``lock`` in place and prunes
+    history to the newest HISTORY_KEEP snapshots.
+    """
     paths.ensure_dirs()
     p = paths.lockfile_path()
     if p.exists():
@@ -96,16 +106,19 @@ def _prune_history() -> None:
 
 
 def get_skill(name: str) -> Optional[dict]:
+    """Return the lock entry for skill ``name``, or None if not installed."""
     return read()["skills"].get(name)
 
 
 def set_skill(name: str, entry: dict) -> None:
+    """Insert or replace the lock entry for skill ``name`` and persist."""
     lock = read()
     lock["skills"][name] = entry
     write(lock)
 
 
 def remove_skill(name: str) -> bool:
+    """Drop skill ``name`` from the lock; return True if it was present."""
     lock = read()
     if name in lock["skills"]:
         del lock["skills"][name]
@@ -115,20 +128,24 @@ def remove_skill(name: str) -> bool:
 
 
 def installed() -> dict:
+    """Return the name -> entry mapping of installed skills."""
     return read()["skills"]
 
 
 def get_rule(name: str) -> Optional[dict]:
+    """Return the lock entry for rule ``name``, or None if not installed."""
     return read()["rules"].get(name)
 
 
 def set_rule(name: str, entry: dict) -> None:
+    """Insert or replace the lock entry for rule ``name`` and persist."""
     lock = read()
     lock["rules"][name] = entry
     write(lock)
 
 
 def remove_rule(name: str) -> bool:
+    """Drop rule ``name`` from the lock; return True if it was present."""
     lock = read()
     if name in lock["rules"]:
         del lock["rules"][name]
@@ -138,20 +155,24 @@ def remove_rule(name: str) -> bool:
 
 
 def installed_rules() -> dict:
+    """Return the name -> entry mapping of installed rules."""
     return read()["rules"]
 
 
 def get_workflow(name: str) -> Optional[dict]:
+    """Return the lock entry for workflow ``name``, or None if not installed."""
     return read()["workflows"].get(name)
 
 
 def set_workflow(name: str, entry: dict) -> None:
+    """Insert or replace the lock entry for workflow ``name`` and persist."""
     lock = read()
     lock["workflows"][name] = entry
     write(lock)
 
 
 def remove_workflow(name: str) -> bool:
+    """Drop workflow ``name`` from the lock; return True if it was present."""
     lock = read()
     if name in lock["workflows"]:
         del lock["workflows"][name]
@@ -161,6 +182,7 @@ def remove_workflow(name: str) -> bool:
 
 
 def installed_workflows() -> dict:
+    """Return the name -> entry mapping of installed workflows."""
     return read()["workflows"]
 
 
@@ -182,6 +204,10 @@ def history_list() -> List[dict]:
 
 
 def history_read(hist_id: str) -> dict:
+    """Return the parsed lock snapshot for history entry ``hist_id``.
+
+    Raises BoostError (with a `boost replay` hint) if no such entry.
+    """
     p = paths.lock_history_dir() / ("lock-%s.json" % hist_id)
     if not p.exists():
         from ..errors import BoostError

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/logs.py

@@ -67,6 +67,7 @@ def _file_stamp() -> str:
 
 
 def log_path() -> Path:
+    """Return the rotating diagnostic log's path (``~/.boost/logs/boost.log``)."""
     return paths.logs_dir() / "boost.log"
 
 
@@ -105,6 +106,7 @@ def _file_enabled() -> bool:
 
 
 def get_logger() -> logging.Logger:
+    """Return the shared ``boost`` logger; :func:`configure` attaches handlers."""
     return logging.getLogger(LOGGER_NAME)
 
 

{boost_skill_cli-1.0.181 → boost_skill_cli-1.0.183}/boost_cli/core/output.py

@@ -45,6 +45,11 @@ def harden_console_encoding() -> None:
 
 
 def use_color(stream=None) -> bool:
+    """True when ANSI color should be emitted on `stream` (default stdout).
+
+    BOOST_COLOR=always/never is boost's explicit override and beats
+    NO_COLOR, CLICOLOR_FORCE and the TTY check.
+    """
     # BOOST_COLOR is boost's own explicit override and wins over everything
     # else (most-specific-wins): always/never force it on/off regardless of
     # NO_COLOR, CLICOLOR_FORCE or the TTY check. Anything else (incl. "auto")
@@ -63,6 +68,7 @@ def use_color(stream=None) -> bool:
 
 
 def c(text: str, *styles: str) -> str:
+    """Wrap text in the given SGR styles + RESET; plain when color is off."""
     if not styles or not use_color():
         return text
     return "".join(styles) + text + RESET
@@ -193,28 +199,34 @@ def gradient(text: str, stream=None) -> str:
 
 
 def ok(msg: str) -> None:
+    """Print msg as an indented success line with a green check mark."""
     print("  " + role("✓", "success") + " " + msg)
 
 
 def warn(msg: str) -> None:
+    """Print msg as an indented `!` warning line, all in the warn role."""
     print("  " + role("!", "warn") + " " + role(msg, "warn"))
 
 
 def err(msg: str, hint: str | None = None) -> None:
+    """Print `Error: msg` to stderr, plus a dim hint line when given."""
     print(c("Error: ", RED, BOLD) + msg, file=sys.stderr)
     if hint:
         print(c("  hint: " + hint, DIM), file=sys.stderr)
 
 
 def info(msg: str = "") -> None:
+    """Print msg indented two spaces; a blank line when msg is empty."""
     print("  " + msg if msg else "")
 
 
 def dim(msg: str) -> None:
+    """Print msg in the muted role (dim when color is on)."""
     print(role(msg, "muted"))
 
 
 def heading(msg: str) -> None:
+    """Print a bold section header led by the accent `==>` marker."""
     # Brand the section marker in the accent role (Aurora cyan — truecolor,
     # 16-color fallback, plain under NO_COLOR) so every command's headers read
     # as one system.
@@ -333,6 +345,7 @@ def meter(fraction: float, width: int = 4) -> str:
 
 
 def kv(key: str, value: str, width: int = 14) -> None:
+    """Print an indented key/value line: dim key padded to width, then value."""
     print("  " + c(key.ljust(width), DIM) + str(value))
 
 
@@ -454,6 +467,11 @@ def table(rows, headers=None) -> None:
 
 
 def confirm(prompt: str, default: bool = False) -> bool:
+    """Ask a yes/no question and return the answer as a bool.
+
+    BOOST_ASSUME_YES or --yes/-y force True; non-TTY stdin and an empty
+    answer return `default`; EOF or Ctrl-C returns False.
+    """
     if os.environ.get("BOOST_ASSUME_YES") or "--yes" in sys.argv or "-y" in sys.argv:
         return True
     if not sys.stdin.isatty():