boost-skill-cli 1.2.105__tar.gz → 1.2.106__tar.gz

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -83,6 +83,7 @@ Langfuse
 LeadMagic
 libFuzzer
 libsodium
+lookarounds
 lookups
 lowercasing
 Magento
@@ -163,6 +164,7 @@ textarea
 toggleable
 Tokenization
 tokenization
+tokenizer
 toolchain
 toolkits
 traceback

{boost_skill_cli-1.2.105/boost_skill_cli.egg-info → boost_skill_cli-1.2.106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.105
+Version: 1.2.106
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -380,11 +380,18 @@ without `--force`.
 boost search jira          # look across every tapped registry
 boost install my-jira      # copy, link, lock — with a quality score attached
 boost doctor               # broken links, lock drift, stale taps
+boost doctor --json        # the same checks as a payload, for CI or an agent
 
 # hand the whole setup to a team:
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
+boost bundle install --dry-run    # …or see what that would tap, install and edit first
 ```
 
+The reporting commands all speak `--json` — `doctor`, `health`, `test`,
+`changelog`, `log`, `trending`, `hooks list`, `clean`, `compact`, `context`
+and `index` — so a script reads a payload instead of parsing prose. Exit codes
+are the same either way.
+
 ## Browsing the catalogue
 
 `boost browse` is a full-screen picker over every tapped item: a filterable list

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/README.md

@@ -338,11 +338,18 @@ without `--force`.
 boost search jira          # look across every tapped registry
 boost install my-jira      # copy, link, lock — with a quality score attached
 boost doctor               # broken links, lock drift, stale taps
+boost doctor --json        # the same checks as a payload, for CI or an agent
 
 # hand the whole setup to a team:
 boost bundle dump > Boostfile     # everyone else runs: boost bundle install
+boost bundle install --dry-run    # …or see what that would tap, install and edit first
 ```
 
+The reporting commands all speak `--json` — `doctor`, `health`, `test`,
+`changelog`, `log`, `trending`, `hooks list`, `clean`, `compact`, `context`
+and `index` — so a script reads a payload instead of parsing prose. Exit codes
+are the same either way.
+
 ## Browsing the catalogue
 
 `boost browse` is a full-screen picker over every tapped item: a filterable list

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.105'
-__version_tuple__ = version_tuple = (1, 2, 105)
+__version__ = version = '1.2.106'
+__version_tuple__ = version_tuple = (1, 2, 106)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/boost_cli/commands/configuration.py

@@ -159,8 +159,12 @@ def cmd_clean(argv) -> int:
                    help="also remove snapshots older than 90 days")
     p.add_argument("-y", "--yes", action="store_true",
                    help="skip the --deep confirmation prompt")
+    p.add_argument("--json", action="store_true", help="machine-readable output")
     args = p.parse_args(argv)
 
+    def row(pth, kind, size):
+        return {"path": str(pth), "kind": kind, "bytes": size}
+
     items: list[tuple[Path, str, int]] = []  # (path, kind, bytes)
     for spec in agents.known_agents().values():
         adir = spec["dir"]
@@ -207,9 +211,14 @@ def cmd_clean(argv) -> int:
         cutoff = time.time() - 90 * 86400
         old_snaps = [s for s in sorted(paths.snapshots_dir().iterdir())
                      if s.lstat().st_mtime < cutoff]
+        # `quiet` under --json for the reason out.confirm documents: on a
+        # non-TTY decline it prints a bypass hint, which would land as a stray
+        # prose line ahead of the payload and stop it parsing.
         if old_snaps and not args.dry_run and not (args.yes or out.confirm(
-                "remove %d snapshot(s) older than 90 days?" % len(old_snaps))):
-            out.info("keeping old snapshots")
+                "remove %d snapshot(s) older than 90 days?" % len(old_snaps),
+                quiet=args.json)):
+            if not args.json:
+                out.info("keeping old snapshots")
             declined = True
             old_snaps = []
         for s in old_snaps:
@@ -220,6 +229,12 @@ def cmd_clean(argv) -> int:
         # `declined` means the only candidate was the --deep snapshot purge
         # and the user said no — "nothing to clean" would claim there was
         # nothing to do when there was, and the user just declined doing it.
+        if args.json:
+            print(json.dumps({"items": [], "count": 0, "bytes": 0,
+                              "dry_run": args.dry_run, "removed": 0,
+                              "failed": [], "declined": declined,
+                              "ok": not declined}, indent=2))
+            return 1 if declined else 0
         if declined:
             return 1
         out.ok("nothing to clean")
@@ -227,6 +242,12 @@ def cmd_clean(argv) -> int:
 
     if args.dry_run:
         freed = sum(size for _, _, size in items)
+        if args.json:
+            print(json.dumps({"items": [row(*i) for i in items],
+                              "count": len(items), "bytes": freed,
+                              "dry_run": True, "removed": 0, "failed": [],
+                              "declined": declined, "ok": True}, indent=2))
+            return 0
         for pth, kind, _size in items:
             out.info("would remove %s %s" % (_tilde(pth), out.role("(%s)" % kind, "muted")))
         out.dim("  %d item(s) · %s would be freed" % (len(items), util.human_size(freed)))
@@ -234,6 +255,16 @@ def cmd_clean(argv) -> int:
 
     removed, freed, failures = util.remove_items(items)
     failed_errors = dict(failures)
+    if args.json:
+        journal.log("clean", "cleaned %d item(s)" % removed,
+                    freed=util.human_size(freed))
+        print(json.dumps(
+            {"items": [row(*i) for i in items], "count": len(items),
+             "bytes": freed, "dry_run": False, "removed": removed,
+             "failed": [{"path": str(pth), "error": err}
+                        for pth, err in failures],
+             "declined": declined, "ok": not failures}, indent=2))
+        return 1 if failures else 0
     for pth, kind, _size in items:
         if pth in failed_errors:
             out.warn("could not remove %s: %s" % (_tilde(pth), failed_errors[pth]),
@@ -292,11 +323,18 @@ def cmd_compact(argv) -> int:
                    help="show what would be reclaimed without touching anything")
     p.add_argument("--reclone", action="store_true",
                    help="re-clone blobless for the smallest result (needs network)")
+    p.add_argument("--json", action="store_true", help="machine-readable output")
     args = p.parse_args(argv)
 
+    rows: list[dict] = []
+
     taps = [registry.get(n) for n in args.tap] if args.tap else registry.list_taps()
     taps = [t for t in taps if t.is_cloned]
     if not taps:
+        if args.json:
+            print(json.dumps({"taps": [], "count": 0, "bytes": 0,
+                              "dry_run": args.dry_run, "ok": True}, indent=2))
+            return 0
         out.ok("no cloned taps to compact")
         return 0
 
@@ -317,8 +355,11 @@ def cmd_compact(argv) -> int:
             if loose:
                 changed += 1
                 freed += loose
-                out.info("would free %s from %s"
-                         % (util.human_size(loose), tap.name))
+                rows.append({"tap": tap.name, "bytes": loose,
+                             "before": before, "after": before - loose})
+                if not args.json:
+                    out.info("would free %s from %s"
+                             % (util.human_size(loose), tap.name))
             continue
         try:
             if args.reclone:
@@ -341,7 +382,9 @@ def cmd_compact(argv) -> int:
             for rel in keep.get(tap.name, []):
                 gitutil.materialize(tap.path, rel)
         except BoostError as e:
-            out.warn("could not compact %s: %s" % (tap.name, e))
+            rows.append({"tap": tap.name, "error": str(e)})
+            out.warn("could not compact %s: %s" % (tap.name, e),
+                     stream=sys.stderr if args.json else None)
             continue
         after = util.dir_size(tap.path)
         # A re-clone did real work — refreshed the clone, possibly moved it
@@ -350,14 +393,26 @@ def cmd_compact(argv) -> int:
         if args.reclone or after < before:
             changed += 1
             freed += max(before - after, 0)
-            out.info("%s  %s → %s" % (tap.name, util.human_size(before),
-                                      util.human_size(after)))
+            rows.append({"tap": tap.name, "bytes": max(before - after, 0),
+                         "before": before, "after": after})
+            if not args.json:
+                out.info("%s  %s → %s" % (tap.name, util.human_size(before),
+                                          util.human_size(after)))
 
     if args.dry_run:
+        if args.json:
+            print(json.dumps({"taps": rows, "count": changed, "bytes": freed,
+                              "dry_run": True, "ok": True}, indent=2))
+            return 0
         out.dim("  %d tap(s) · %s would be freed"
                 % (changed, util.human_size(freed)))
         return 0
     journal.log("compact", "%d taps" % changed, freed=util.human_size(freed))
+    if args.json:
+        print(json.dumps({"taps": rows, "count": changed, "bytes": freed,
+                          "dry_run": False,
+                          "ok": not any("error" in r for r in rows)}, indent=2))
+        return 0
     if not changed:
         out.ok("every tap is already compact")
         return 0
@@ -1281,9 +1336,15 @@ def _tool_search(args: dict):
         entries = [e for e, _score in catalog.search(query)[:10]]
         ranker = FRONTMATTER_RANKER
     if not entries:
-        # mcp.no_results owns the empty reply on both paths, including the
-        # untapped-machine branch that must not read as a genuine miss.
-        return mcp.no_results(query, tapped=tapped), False
+        # mcp.no_results owns the empty reply on all three paths: a genuine
+        # miss, the untapped machine that must not read as one, and a query
+        # every word of which fell out of the tokenizer. The third is asked
+        # only of the RAG branch — `catalog.search` is a substring match and
+        # discards nothing, so a notice there would describe another engine.
+        dropped = (rag.dropped_terms(query)
+                   if rag_result is not None
+                   and rag.tokenizer_is_the_only_reader() else [])
+        return mcp.no_results(query, tapped=tapped, dropped=dropped), False
     # Name-keyed, the same test `lockfile.find_any` and `store.install` apply —
     # those are the tools this marker is advising about. mcp.hit_line's
     # docstring records why the imprecision is disclosed rather than removed,

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/boost_cli/commands/discovery.py

@@ -165,15 +165,35 @@ def cmd_search(argv):
     if args.category:
         scored = [(e, s) for e, s in scored
                  if catalog.matches_category(e, args.category)]
+    # One measurement, three branches below: the words the index cannot hold.
+    # Two gates, and each excludes an engine that did not drop anything.
+    # `catalog.search` is a substring match, so the non-RAG path discards
+    # nothing; and `dense.retrieve` embeds the raw query string, so on a
+    # machine with vectors built the term reached an index after all.
+    dropped = (rag.dropped_terms(query)
+               if use_rag and rag.tokenizer_is_the_only_reader() else [])
     if not scored:
         if args.as_json:
             print(json.dumps([]))
+            _warn_dropped_terms(dropped)
             return 0
-        # The standardized ○/→ empty state, so "nothing here" reads the same
-        # as every other command's; both wordings are pinned by tests.
-        print(out.empty_state(
-            "no matches for %r" % query,
-            "try `boost discover %s` to search all of GitHub" % query))
+        if dropped and not rag.tokenize(query):
+            # Nothing was searched at all, so "no matches" asserts something
+            # this command never checked, and `boost discover` spends a network
+            # round trip on a query that never reached an index. Measured: a
+            # bare `C++` gave the empty state below on a corpus holding 45
+            # entries naming the language.
+            print(out.empty_state(
+                "no searchable terms in %r" % query,
+                "a term needs 2 or more ASCII letters or digits — %s"
+                % _quoted(dropped)))
+        else:
+            # The standardized ○/→ empty state, so "nothing here" reads the same
+            # as every other command's; both wordings are pinned by tests.
+            print(out.empty_state(
+                "no matches for %r" % query,
+                "try `boost discover %s` to search all of GitHub" % query))
+            _note_dropped_terms(dropped)
         _hint_semantic_search(engine)
         # Especially here: "no matches" is exactly the answer an out-of-date
         # tap set produces, and the user has no other way to suspect it.
@@ -204,6 +224,7 @@ def cmd_search(argv):
         # rows carry `ranker`. Both hold.
         print(json.dumps([catalog.public_entry(e) | {"score": s, "ranker": ranker}
                           for e, s in scored[:args.limit]]))
+        _warn_dropped_terms(dropped)
         return 0
     shown = scored[:args.limit]
     # The dot marks "a skill by this name is installed" — a name match, with
@@ -238,6 +259,7 @@ def cmd_search(argv):
     out.info(out.role(footer, "muted"))
     if use_rag:
         _note_stem_expansions(query)
+        _note_dropped_terms(dropped)
     _hint_semantic_search(engine)
     _hint_stale_taps()
     return 0
@@ -260,6 +282,44 @@ def _note_stem_expansions(query: str) -> None:
         max(0, out.term_width() - 2)), "muted"))
 
 
+#: How the index's own rule reads to someone who just lost a word to it.
+_TERM_RULE = "a term needs 2 or more ASCII letters or digits"
+
+
+def _quoted(terms: list[str]) -> str:
+    return ", ".join("%r" % t for t in terms)
+
+
+def _note_dropped_terms(dropped: list[str]) -> None:
+    """Say which words were not searched, next to the results they are not in.
+
+    The erasure was the defect. `boost search 'c++ testing'` answered with
+    results for `testing` and said nothing, so it was byte-identical to
+    `boost search 'c# testing'` and to `boost search testing` — three
+    questions, one answer, no way to tell from the output. Aliasing rescues
+    the languages boost can name (`rag.SYMBOL_ALIASES`); this is for the rest,
+    where the honest answer is that the word never reached an index.
+    """
+    if not dropped:
+        return
+    out.info(out.role(out.truncate(
+        "not searched: %s — %s" % (_quoted(dropped), _TERM_RULE),
+        max(0, out.term_width() - 2)), "muted"))
+
+
+def _warn_dropped_terms(dropped: list[str]) -> None:
+    """The same fact on stderr, so `--json` cannot swallow it.
+
+    Same contract as this command's `--smart` fallback note: a script reading
+    stdout as JSON must still learn that half its query was discarded, and an
+    empty `[]` is exactly what a genuine miss looks like.
+    """
+    if not dropped:
+        return
+    out.warn("not searched: %s — %s" % (_quoted(dropped), _TERM_RULE),
+             wrap=True, stream=sys.stderr)
+
+
 def _hint_stale_taps() -> None:
     """Mention old tap clones. One `stat`, and never a network call.
 
@@ -645,6 +705,8 @@ def cmd_index(argv):
                    help="narrow the sample to these terms (default: any SKILL.md)")
     p.add_argument("--limit", type=util.positive_int, default=300,
                    help="max skill files to index (default 300)")
+    p.add_argument("--json", action="store_true", dest="as_json",
+                   help="machine-readable output")
     args = p.parse_args(argv)
     if not shutil.which("gh"):
         raise BoostError("the GitHub CLI (gh) is required to build the index",
@@ -703,17 +765,30 @@ def cmd_index(argv):
     dpath = _discovery_path()
     if not discovery_core.should_write_index(len(items), dpath.exists()):
         prev = _index_item_count(dpath)
+        # stderr under --json: the notice has to survive, and putting it on
+        # stdout would corrupt the payload it accompanies. Same rule out.warn
+        # documents for the commands that speak JSON there.
         out.warn("no SKILL.md files match %s — keeping the previous index "
-                 "of %d entries" % (query or "your query", prev))
+                 "of %d entries" % (query or "your query", prev),
+                 stream=sys.stderr if args.as_json else None)
+        if args.as_json:
+            print(json.dumps({"written": False, "indexed": 0, "repos": 0,
+                              "github_total": total, "query": query,
+                              "previous": prev}, indent=2))
         return 0
     paths.ensure_dirs()
     dpath.write_text(json.dumps(
         {"generated": util.now_iso(), "github_total": total, "query": query,
          "items": items}, indent=1), encoding="utf-8")
     repos = len({it["repo"] for it in items})
+    journal.log("index", "%d skill files" % len(items), total=total)
+    if args.as_json:
+        print(json.dumps({"written": True, "indexed": len(items),
+                          "repos": repos, "github_total": total,
+                          "query": query, "path": str(dpath)}, indent=2))
+        return 0
     out.ok("indexed %d skill files across %d repos (GitHub reports %d total)"
            % (len(items), repos, total))
-    journal.log("index", "%d skill files" % len(items), total=total)
     return 0
 
 
@@ -1874,6 +1949,8 @@ def cmd_trending(argv):
         description="Show trending items by install count")
     p.add_argument("--limit", type=util.positive_int, default=10,
                    help="max rows (default 10)")
+    p.add_argument("--json", action="store_true", dest="as_json",
+                   help="machine-readable output")
     args = p.parse_args(argv)
     evs = journal.events(action="install")
     # setdefault, not a dict comprehension: a comprehension keeps the LAST
@@ -1885,8 +1962,21 @@ def cmd_trending(argv):
     for e in catalog.all_entries():
         by_name.setdefault(e["name"], e)
     if not evs:
+        curated = sorted((e for e in by_name.values() if e.get("curated")),
+                         key=operator.itemgetter("name"))[:args.limit]
+        if args.as_json:
+            # `source` names which of the two lists this is. They answer
+            # different questions — what this machine installs versus what the
+            # catalogue recommends — and a consumer that could not tell them
+            # apart would read curated picks as local activity.
+            print(json.dumps(
+                {"source": "curated", "items": [
+                    {"name": e["name"], "version": e["version"],
+                     "kind": e.get("kind", "skill"),
+                     "description": e.get("description", "")}
+                    for e in curated]}, indent=2))
+            return 0
         out.heading("curated picks (no local install data yet)")
-        curated = [e for e in by_name.values() if e.get("curated")]
         if not curated:
             out.info("no curated skills available — add taps with `boost tap --defaults`")
             return 0
@@ -1894,7 +1984,7 @@ def cmd_trending(argv):
         descw = max(out.term_width() - 34, 24)
         out.table([(e["name"], "v" + e["version"], e.get("kind", "skill"),
                     out.truncate(e["description"], descw))
-                   for e in sorted(curated, key=operator.itemgetter("name"))[:args.limit]],
+                   for e in curated],
                   headers=("name", "version", "kind", "description"))
         return 0
     agg: dict[str, Any] = {}
@@ -1903,6 +1993,17 @@ def cmd_trending(argv):
         rec = agg.setdefault(name, {"count": 0, "last": ev.get("ts", "")})
         rec["count"] += 1
     ranked = sorted(agg.items(), key=lambda kv: (-kv[1]["count"], kv[0]))
+    if args.as_json:
+        # `kind` is carried so rules and workflows stay distinguishable —
+        # the prose table shows it, and a payload that dropped it would make
+        # every row look like a skill.
+        print(json.dumps(
+            {"source": "installs", "items": [
+                {"name": name, "installs": rec["count"], "last": rec["last"],
+                 "kind": by_name.get(name, {}).get("kind", "skill"),
+                 "description": by_name.get(name, {}).get("description", "")}
+                for name, rec in ranked[:args.limit]]}, indent=2))
+        return 0
     # reserve name/installs/last/kind columns
     descw = max(out.term_width() - 54, 24)
     out.table([(name, str(rec["count"]), util.rel_time(rec["last"]),

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/boost_cli/commands/hooks.py

@@ -24,6 +24,8 @@ are left untouched. See core/claude_settings.py.
 """
 from __future__ import annotations
 
+import json
+
 from .. import cliparse
 from ..core import claude_settings as cs
 from ..core import hookhost, journal, util
@@ -53,22 +55,34 @@ def cmd_hooks(argv) -> int:
                    help="Claude matcher, e.g. 'startup|resume|clear'")
     p.add_argument("--timeout", type=util.positive_int, default=10,
                    help="hook timeout in seconds (default: 10)")
+    p.add_argument("--json", action="store_true", dest="as_json",
+                   help="machine-readable output (list)")
     args = p.parse_args(argv)
 
     if args.action == "list":
-        return _list(args.scope, args.host, args.event)
+        return _list(args.scope, args.host, args.event, args.as_json)
     if args.action == "add":
         return _add(args)
     return _remove(args)
 
 
-def _list(scope, host, event=None) -> int:
+def _list(scope, host, event=None, as_json=False) -> int:
     rows = cs.list_all_hooks(scope, host=host)
     if event:
         # Each row is already tagged with its own host, so filter against
         # that host's native spelling rather than the one the caller typed —
         # `hooks list` (no --host) mixes Claude and Gemini rows in one table.
         rows = [r for r in rows if r["event"] == hookhost.translate(r["host"], event)]
+    if as_json:
+        # Every field the table shows, and `timeout` besides — it is in the
+        # rows already and is the one value a reader cannot see in the prose
+        # listing at all.
+        print(json.dumps({"hooks": [
+            {"host": r["host"], "scope": r["scope"], "event": r["event"],
+             "name": r["name"], "matcher": r["matcher"] or None,
+             "command": r["command"], "timeout": r.get("timeout")}
+            for r in rows]}, indent=2))
+        return 0
     if not rows:
         out.info("no boost-managed hooks" + (" in %s scope" % scope if scope else "")
                  + (" for event '%s'" % event if event else ""))

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/boost_cli/commands/info.py

@@ -881,31 +881,50 @@ def _diag_line(line: str) -> str:
                                rec.get("logger", ""), rec["msg"])
 
 
-def _show_diagnostics(limit):
+def _show_diagnostics(limit, as_json=False):
     lp = logs.log_path()
     if not lp.exists():
+        if as_json:
+            print(json.dumps({"kind": "diagnostics", "path": str(lp),
+                              "lines": []}, indent=2))
+            return 0
         out.info("no diagnostic log yet at %s" % lp)
         return 0
     lines = lp.read_text(encoding="utf-8", errors="replace").splitlines()
+    if as_json:
+        # Raw lines, not the coloured `_diag_line` rendering: the decoration
+        # is display, and a consumer parsing it would be parsing our palette.
+        print(json.dumps({"kind": "diagnostics", "path": str(lp),
+                          "lines": lines[-limit:]}, indent=2))
+        return 0
     out.heading("diagnostic log — %s" % lp)
     for line in lines[-limit:]:
         out.info(_diag_line(line))
     return 0
 
 
-def _show_crashes(limit):
+def _crash_summary(r):
+    try:
+        first = r.read_text(encoding="utf-8", errors="replace").splitlines()
+        return next((ln for ln in first if ln.startswith("command:")), "")
+    except OSError:
+        return ""
+
+
+def _show_crashes(limit, as_json=False):
     ldir = paths.logs_dir()
     reports = sorted(ldir.glob("crash-*.log"), reverse=True) if ldir.is_dir() else []
+    if as_json:
+        print(json.dumps({"kind": "crashes", "dir": str(ldir), "reports": [
+            {"name": r.name, "path": str(r), "summary": _crash_summary(r)}
+            for r in reports[:limit]]}, indent=2))
+        return 0
     if not reports:
         out.info("no crash reports — nothing has blown up (that boost noticed)")
         return 0
     out.heading("crash reports in %s" % ldir)
     for r in reports[:limit]:
-        try:
-            first = r.read_text(encoding="utf-8", errors="replace").splitlines()
-            summary = next((ln for ln in first if ln.startswith("command:")), "")
-        except OSError:
-            summary = ""
+        summary = _crash_summary(r)
         out.info("%s  %s" % (r.name, summary))
     out.info("")
     out.dim("  view one with:  cat %s/<name>" % ldir)
@@ -922,13 +941,15 @@ def cmd_log(argv):
                     help="show boost's diagnostic log trail (not skill history)")
     ap.add_argument("--crashes", action="store_true",
                     help="list recent crash reports")
+    ap.add_argument("--json", action="store_true", dest="as_json",
+                    help="machine-readable output")
     args = ap.parse_args(argv)
     if args.name and (args.crashes or args.diagnostics):
         ap.error("NAME is not used with --diagnostics/--crashes")
     if args.crashes:
-        return _show_crashes(args.limit)
+        return _show_crashes(args.limit, args.as_json)
     if args.diagnostics:
-        return _show_diagnostics(args.limit)
+        return _show_diagnostics(args.limit, args.as_json)
     if args.name:
         _, bare = catalog.split_name(args.name)
         found = lockfile.find_any(args.name)
@@ -944,11 +965,24 @@ def cmd_log(argv):
         try:
             tap = registry.get(tap_name)
         except BoostError:
+            if args.as_json:
+                print(json.dumps({"kind": "history", "name": bare,
+                                  "tap": None, "commits": []}, indent=2))
+                return 0
             out.info("no upstream history (imported locally)")
             return 0
         if not tap.is_cloned:
             raise BoostError("tap %s is not cloned" % tap.name,
                             hint="run `boost update %s`" % tap.name)
+        if args.as_json:
+            # `log_entries`, not a re-split of the display format: the columns
+            # there are two-space separated and an author or subject may
+            # contain that run.
+            print(json.dumps(
+                {"kind": "history", "name": bare, "tap": tap.name,
+                 "commits": gitutil.log_entries(tap.path, rel, args.limit)},
+                indent=2))
+            return 0
         lines = gitutil.log_for_path(tap.path, rel, args.limit)
         if not lines:
             out.info("no commits touch %s in %s" % (bare, tap.name))
@@ -958,6 +992,12 @@ def cmd_log(argv):
             out.info(line)
         return 0
     events = journal.events(args.limit)
+    if args.as_json:
+        # Verbatim, which is the point: the prose listing drops the
+        # `key=value` event fields `pulse --json` shows over the same journal,
+        # and this is the command a consumer reaches for first.
+        print(json.dumps({"kind": "activity", "events": events}, indent=2))
+        return 0
     if not events:
         out.info("no activity yet")
         return 0

{boost_skill_cli-1.2.105 → boost_skill_cli-1.2.106}/boost_cli/commands/intelligence.py

@@ -869,6 +869,11 @@ def cmd_context(argv: list[str]) -> int:
     # metavar="ACTION": the full "status|enable|disable|map|unmap|apply"
     # spelling is one unbreakable token that overflowed the usage line at 60
     # columns. Each subcommand still lists its own help= below.
+    # A separate dest from the `status` subparser's own --json. Both land in
+    # one namespace, so sharing `json` would let the subparser's default
+    # overwrite a flag given before the action.
+    ap.add_argument("--json", action="store_true", dest="top_json",
+                    help="machine-readable output (bare `context` = status)")
     sub = ap.add_subparsers(dest="action", metavar="ACTION")
     sp = sub.add_parser("status", help="show rules, enabled flag & branch")
     sp.add_argument("--json", action="store_true")
@@ -886,7 +891,11 @@ def cmd_context(argv: list[str]) -> int:
     action = args.action or "status"
 
     if action == "status":
-        return _context_status(state, getattr(args, "json", False))
+        # Bare `boost context` means status, so `boost context --json` has to
+        # mean `context status --json` — it was the one spelling that was
+        # rejected while both halves of it worked.
+        return _context_status(state,
+                               getattr(args, "json", False) or args.top_json)
     if action == "map":
         skills = [s.strip() for s in args.skills.split(",") if s.strip()]
         if not skills: