boost-skill-cli 1.2.96__tar.gz → 1.2.97__tar.gz

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/.vale/styles/config/vocabularies/boost/accept.txt

@@ -37,6 +37,8 @@ CRM
 cron
 crontab
 cyclomatic
+dedupe
+deduped
 Dependabot
 deps
 deserialization

{boost_skill_cli-1.2.96/boost_skill_cli.egg-info → boost_skill_cli-1.2.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.96
+Version: 1.2.97
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -421,6 +421,13 @@ at least 95% alike, fold into one badged `×5`, with `^D` to show them again.
 Identity is the description and never the name: `code-reviewer` appears 75 times
 with 42 different descriptions, and those are 42 real skills.
 
+Without a real TTY (a pipe, an IDE run console, a terminal curses can't drive)
+`browse` falls back to a plain, deduped table — name, version, tap, kind — with
+a footer breaking the total down by kind and pointing at `boost search` to
+narrow it. The same fallback covers a curses initialization failure, so a
+terminal that merely *claims* `isatty()` degrades gracefully instead of
+crashing mid-draw.
+
 ## 81 commands, organized into 8 groups
 
 `boost --help` prints the full grouped list. For every flag of every command see

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/README.md

@@ -379,6 +379,13 @@ at least 95% alike, fold into one badged `×5`, with `^D` to show them again.
 Identity is the description and never the name: `code-reviewer` appears 75 times
 with 42 different descriptions, and those are 42 real skills.
 
+Without a real TTY (a pipe, an IDE run console, a terminal curses can't drive)
+`browse` falls back to a plain, deduped table — name, version, tap, kind — with
+a footer breaking the total down by kind and pointing at `boost search` to
+narrow it. The same fallback covers a curses initialization failure, so a
+terminal that merely *claims* `isatty()` degrades gracefully instead of
+crashing mid-draw.
+
 ## 81 commands, organized into 8 groups
 
 `boost --help` prints the full grouped list. For every flag of every command see

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/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.96'
-__version_tuple__ = version_tuple = (1, 2, 96)
+__version__ = version = '1.2.97'
+__version_tuple__ = version_tuple = (1, 2, 97)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/configuration.py

@@ -401,7 +401,7 @@ def cmd_create(argv) -> int:
                    help="install the new skill immediately")
     args = p.parse_args(argv)
 
-    name = util.slugify(args.name)
+    name = util.resolve_slug(args.name)
     parent = paths.expand(args.dir) if args.dir else Path.cwd()
     target = parent / name
     skill_md = target / "SKILL.md"
@@ -823,6 +823,17 @@ def cmd_completions(argv) -> int:
 
     detected = args.shell or Path(os.environ.get("SHELL", "")).name
 
+    # Fixed once, here, rather than in each branch below: an empty $SHELL
+    # used to fall through silently to the bash script (print path) or to
+    # `_rc_path("")`'s confusing "no one-shot install for  yet" (install
+    # path) — neither ever told the user *why*. Raising here means every
+    # path downstream — print, --install, --uninstall, --dry-run — sees the
+    # same clear error instead of reinventing it.
+    if not detected:
+        raise BoostError(
+            "cannot detect your shell ($SHELL unset)",
+            hint="pass bash, zsh or fish, e.g. `boost completions bash`")
+
     if args.dry_run and not (args.install or args.uninstall):
         p.error("--dry-run qualifies --install or --uninstall; "
                 "pass one of them")
@@ -851,6 +862,15 @@ def cmd_completions(argv) -> int:
         return 0
 
     shell = detected if detected in ("bash", "zsh", "fish") else "bash"
+    if shell != detected:
+        # A real shell boost has no script for (e.g. nu, xonsh) — silently
+        # substituting bash used to look like success while handing the user
+        # a script their shell cannot source. stderr, not stdout: stdout here
+        # is the completion script itself (piped to a file or `eval`'d), and
+        # a warning line mixed into it would corrupt both uses.
+        out.warn("%s is not a supported shell (bash, zsh, fish) — showing "
+                 "bash's completion script instead" % detected,
+                 stream=sys.stderr)
     # The script is a thin shim that calls `boost __complete`; the candidate
     # rules live in core/complete.py so all three shells share one tested
     # implementation instead of three hand-maintained static lists.

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/discovery.py

@@ -994,11 +994,23 @@ def cmd_recommend(argv):
 
 def _browse_plain(entries, why: str):
     out.warn(why + " — showing the full catalog")
-    out.table([(e["name"], "v" + e["version"], e["tap"],
-                "★" if e.get("curated") else "") for e in entries],
-              headers=("name", "version", "tap", ""))
-    out.info(out.role("%d skills · install with `boost install <name>`"
-                   % len(entries), "muted"))
+    # Same collapse the TUI does: a registry renders one skill into
+    # .claude/, .cursor/, .gemini/ and a plugin root, and this fallback used
+    # to list every copy with nothing to tell them apart.
+    unique = [e for e, _n in browse.dedupe(entries)]
+    show_curated = any(e.get("curated") for e in unique)
+    headers = ["name", "version", "tap", "kind"]
+    rows = [[e["name"], "v" + e["version"], e["tap"],
+             out.kind_label(e.get("kind", "skill"))]
+            for e in unique]
+    if show_curated:
+        headers.append("")
+        for row, e in zip(rows, unique, strict=True):
+            row.append("★" if e.get("curated") else "")
+    out.table([tuple(row) for row in rows], headers=tuple(headers))
+    out.info(out.role(
+        "%s · install with `boost install <name>` · narrow with `boost search <query>`"
+        % browse.plain_footer(unique), "muted"))
     return 0
 
 
@@ -1747,7 +1759,17 @@ def cmd_browse(argv):
         import curses
     except ImportError:
         return _browse_plain(entries, "curses is unavailable on this Python")
-    picked = _browse_tui(curses, entries)
+    try:
+        picked = _browse_tui(curses, entries)
+    except curses.error as e:
+        # An fd that claims isatty() but isn't a real pty (IDE run consoles,
+        # `script`, TERM=dumb) can fail deep inside curses.wrapper's own
+        # setup/teardown rather than at the isatty() check above. wrapper
+        # already ran its finally block (endwin() included), so the screen is
+        # restored by the time this is caught — printing here lands on a
+        # normal terminal, not a hosed one.
+        return _browse_plain(entries,
+                             "the terminal does not support curses (%s)" % e)
     if not picked:
         return 0
     # The browser installs in place now, so anything it hands back is usually

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/info.py

@@ -703,8 +703,18 @@ def cmd_preview(argv):
     args = ap.parse_args(argv)
     text, _kind, lock, cat = _resolve_text(args.name)
     meta, body = frontmatter.parse(text)
+    if not sys.stdout.isatty():
+        # A piped/redirected preview renders nothing — no ANSI, so the
+        # per-chunk `_inline()` substitution would strip `**`/backtick
+        # markers with no styled substitute, and lines with no special-cased
+        # handling (a bare `---`, a wrapped `> quote` continuation) print
+        # mangled rather than as either faithful Markdown or a real render.
+        # `boost cat` already resolves this the same way: raw text through.
+        sys.stdout.write(body if body.endswith("\n") else body + "\n")
+        return 0
+    version = meta.get("version") or (lock or cat or {}).get("version") or "?"
     print(out.titlebar("%s · v%s · %s" % (meta.get("name") or args.name,
-                                          meta.get("version") or "?",
+                                          version,
                                           (lock or cat or {}).get("tap", "local"))))
     print()
     _render_markdown(body)

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/intelligence.py

@@ -14,6 +14,7 @@ import difflib
 import fnmatch
 import json
 import re
+import shlex
 import sys
 import tempfile
 import textwrap
@@ -213,7 +214,8 @@ def cmd_distill(argv: list[str]) -> int:
         meta, body = frontmatter.parse(text)
         sources.append({"name": name, "origin": origin, "text": text,
                         "meta": meta, "body": body})
-    new = args.output or (names[0] + "-distilled")
+    new = util.resolve_slug(args.output, what="output name") if args.output \
+        else names[0] + "-distilled"
 
     out.heading("distilling %s → %s" % (", ".join(names), new))
     merged = _distill_ai(new, sources) if ai.available() else None
@@ -227,7 +229,9 @@ def cmd_distill(argv: list[str]) -> int:
         dest = Path.cwd() / new / "SKILL.md"
         if not _write_generated(dest, merged, yes=args.yes):
             return 1
-        out.info(out.role("install it with `boost import ./%s`" % new, "muted"))
+        out.info(out.role(
+            "install it with `boost import %s`" % shlex.quote("./" + new),
+            "muted"))
     journal.log("distill", new, sources=names)
     return 0
 

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/pkg.py

@@ -21,6 +21,7 @@ from .. import cliparse, spin
 from ..core import (
     adapters,
     agents,
+    archive,
     catalog,
     complete,
     config,
@@ -1769,11 +1770,17 @@ def cmd_export(argv: list[str]) -> int:
                                  "agent config files; reinstall them "
                                  "from their tap")
         if not store.skill_store_dir(name).is_dir():
-            raise BoostError("store dir for %s is missing" % name,
-                            hint="repair with `boost sync`")
+            raise BoostError(
+                "store dir for %s is missing" % name,
+                hint=("repair with `boost reinstall %s`" % name)
+                     if entry.get("tap") == "local"
+                     else "repair with `boost sync`")
         chosen[name] = entry
     stamp = datetime.now(UTC).strftime("%Y%m%d")
-    ext = ".zip" if args.zip else ".tar.gz"
+    use_zip, format_warning = archive.resolve_export_format(args.out, args.zip)
+    if format_warning:
+        out.warn(format_warning)
+    ext = ".zip" if use_zip else ".tar.gz"
     dest = paths.expand(args.out) if args.out else Path(
         "boost-skills-%s%s" % (stamp, ext))
     if dest.exists() and not args.force:
@@ -1782,9 +1789,10 @@ def cmd_export(argv: list[str]) -> int:
                              "different -o path")
     manifest = _boostfile_text(chosen, via="boost export")
     try:
-        if args.zip:
+        if use_zip:
             with zipfile.ZipFile(str(dest), "w", zipfile.ZIP_DEFLATED) as zf:
-                zf.writestr("Boostfile", manifest)
+                zf.writestr(archive.boostfile_zipinfo(
+                    datetime.now(UTC).timetuple()[:6]), manifest)
                 for name in chosen:
                     sdir = store.skill_store_dir(name)
                     for f in sorted(p for p in sdir.rglob("*") if p.is_file()):
@@ -1796,9 +1804,10 @@ def cmd_export(argv: list[str]) -> int:
                 ti.size = len(data)
                 ti.mtime = int(datetime.now(UTC).timestamp())
                 ti.mode = 0o644
-                tf.addfile(ti, io.BytesIO(data))
+                tf.addfile(archive.normalize_tar_member(ti), io.BytesIO(data))
                 for name in chosen:
-                    tf.add(str(store.skill_store_dir(name)), arcname=name)
+                    tf.add(str(store.skill_store_dir(name)), arcname=name,
+                          filter=archive.normalize_tar_member)
     except OSError as e:
         raise BoostError("cannot write %s: %s" % (_tilde(dest), e.strerror or e),
                         hint="check the output path exists and is writable") from e

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/quality.py

@@ -1294,15 +1294,27 @@ def cmd_health(argv):
         prog="boost health", description="Dashboard of skill-environment health")
     ap.parse_args(argv)
 
-    installed = _iter_installed()
-    quarantined = sum(1 for _n, e in installed if e.get("quarantined"))
-    pinned = sum(1 for _n, e in installed if e.get("pinned"))
+    # Skills-only used to be the whole dashboard, so a rule or workflow could
+    # drift — or vanish from the store entirely — invisibly: the skills line
+    # and the drift row below both only ever saw `_iter_installed()`. Walking
+    # every kind here is what lets the drift row match `boost drift` on the
+    # same lock file instead of silently under-reporting it.
+    all_installed = _iter_installed_all()
+    by_kind: dict[str, list[tuple[str, dict]]] = {}
+    for kind, name, entry in all_installed:
+        by_kind.setdefault(kind, []).append((name, entry))
+    installed = by_kind.get("skill", [])
     taps = registry.list_taps()
     cloned = [t for t in taps if t.is_cloned]
 
     out.heading("boost health")
-    out.kv("skills", "%d installed · %d quarantined · %d pinned"
-           % (len(installed), quarantined, pinned))
+    for kind, label in (("skill", "skills"), ("rule", "rules"),
+                        ("workflow", "workflows")):
+        items = by_kind.get(kind, [])
+        q = sum(1 for _n, e in items if e.get("quarantined"))
+        p = sum(1 for _n, e in items if e.get("pinned"))
+        out.kv(label, "%d installed · %d quarantined · %d pinned"
+               % (len(items), q, p))
     out.kv("taps", "%d configured · %d cloned" % (len(taps), len(cloned)))
 
     expected = [n for n, e in installed if not e.get("quarantined")]
@@ -1315,17 +1327,25 @@ def cmd_health(argv):
         out.kv(agent, "%d/%d %s" % (linked, len(expected),
                                     out.role("✓", "success") if full
                                     else out.role("!", "warn")))
-    # Agents that read the canonical store have no links to count — scoring
-    # them 0/N would report a healthy setup as broken. They are listed anyway,
-    # because an agent silently absent from a health report reads as "boost is
-    # not wired up for it".
+    # Agents that read the canonical store have no links to count, so they
+    # used to be scored an unconditional len(expected)/len(expected) — green
+    # even with a skill's store directory gone, in the same report `drift`
+    # called store-missing. Stat the store instead. They are listed even when
+    # full, because an agent silently absent from a health report reads as
+    # "boost is not wired up for it".
+    store_present = sum(1 for n in expected if store.skill_store_dir(n).is_dir())
+    store_full = store_present == len(expected)
     for agent in agents.native_store_agents():
+        coverage_ok = coverage_ok and store_full
         out.kv(agent, "%d/%d %s (reads the store directly)"
-               % (len(expected), len(expected), out.role("✓", "success")))
+               % (store_present, len(expected),
+                  out.role("✓", "success") if store_full
+                  else out.role("!", "warn")))
 
     drift_counts: dict = {}
-    for name, entry in installed:
-        st = _drift_status(name, entry)
+    for kind, name, entry in all_installed:
+        st = (_drift_status(name, entry) if kind == "skill"
+              else _drift_status_materialized(kind, name, entry))
         drift_counts[st] = drift_counts.get(st, 0) + 1
     out.kv("drift", " · ".join("%d %s" % (n, s)
                                for s, n in sorted(drift_counts.items())) or "—")

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/taps.py

@@ -190,32 +190,26 @@ def cmd_tap(argv) -> int:
     return rc
 
 
-def cmd_untap(argv) -> int:
-    """boost untap NAME [--force]"""
-    p = cliparse.parser(
-        prog="boost untap",
-        description="Remove a registry tap")
-    p.add_argument("name", help="tap name (owner/repo or short alias)")
-    p.add_argument("-f", "--force", action="store_true",
-                   help="skip the confirmation prompt")
-    p.add_argument("-y", "--yes", action="store_true", help=argparse.SUPPRESS)
-    args = p.parse_args(argv)
+def _untap_one(name: str, force: bool) -> int:
+    """Remove one tap, warning on and confirming past live dependents.
 
-    tap = registry.get(args.name)
-    # All three lock sections: untapping the source of a live CLAUDE.md rule
-    # deserves the same warning as untapping the source of a skill.
-    dependent = [(kind, n)
-                 for kind, section in lockfile.all_installed().items()
-                 for n, e in sorted(section.items())
-                 if e.get("tap") == tap.name]
+    One tap's failure (unknown name, declined confirmation) never costs the
+    rest of a multi-name `untap` its removal, matching `tap`'s own multi-SPEC
+    guarantee that one registry's failure never costs another its clone.
+    """
+    try:
+        tap = registry.get(name)
+    except BoostError as exc:
+        out.warn("could not untap %s: %s" % (name, exc.message))
+        return 1
+    dependent = registry.dependents(tap.name)
     if dependent:
         labels = [n if kind == "skill" else "%s (%s)" % (n, kind)
                   for kind, n in dependent]
         out.warn("%d installed item(s) from %s: %s"
                  % (len(dependent), tap.name, ", ".join(labels)))
         out.warn("installed items keep working but lose their update source")
-        if not (args.force or args.yes) and not out.confirm(
-                "untap %s anyway?" % tap.name):
+        if not force and not out.confirm("untap %s anyway?" % tap.name):
             out.info("cancelled")
             return 1
     registry.remove(tap.name)
@@ -225,6 +219,26 @@ def cmd_untap(argv) -> int:
     return 0
 
 
+def cmd_untap(argv) -> int:
+    """boost untap NAME... [--force]"""
+    p = cliparse.parser(
+        prog="boost untap",
+        description="Remove a registry tap")
+    p.add_argument("name", nargs="+",
+                   help="tap name(s) (owner/repo or short alias) — several "
+                        "at once remove one invocation per tap")
+    p.add_argument("-f", "--force", action="store_true",
+                   help="skip the confirmation prompt")
+    p.add_argument("-y", "--yes", action="store_true", help=argparse.SUPPRESS)
+    args = p.parse_args(argv)
+
+    force = args.force or args.yes
+    rc = 0
+    for name in args.name:
+        rc |= _untap_one(name, force)
+    return rc
+
+
 def _tap_updated(tap: registry.Tap) -> str:
     """Last-commit date of a tap clone, else the cache's generated date.
 

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/commands/team.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import operator
 import platform
 import shutil
 import stat
@@ -205,7 +206,7 @@ def cmd_cohort(argv) -> int:
 # ---------------------------------------------------------------- profile
 
 def _profile_path(name: str):
-    return paths.profiles_dir() / (util.slugify(name) + ".json")
+    return paths.profiles_dir() / (util.resolve_slug(name, what="profile name") + ".json")
 
 
 def _load_profile(name: str) -> dict:
@@ -274,6 +275,10 @@ def cmd_profile(argv) -> int:
                              "skills": len(data.get("skills", {})),
                              "saved": data.get("saved", "?"),
                              "unreadable": False})
+        # Sort by the name shown on screen, not the slugged filename that put
+        # them there — glob order otherwise prints rows in an order that
+        # matches nothing a reader sees (`daily, mixed, !!!, Work Profile`).
+        profiles.sort(key=operator.itemgetter("name"))
         if args.json:
             print(json.dumps(profiles, indent=2))
             return 0
@@ -291,18 +296,19 @@ def cmd_profile(argv) -> int:
 
     if args.action == "save":
         installed = lockfile.installed()
+        path = _profile_path(args.name)
         was = None
-        if _profile_path(args.name).exists():
+        if path.exists():
             try:
-                was = len(_load_profile(args.name).get("skills", {}))
-            except BoostError:
+                was = len(json.loads(path.read_text(encoding="utf-8")).get("skills", {}))
+            except (json.JSONDecodeError, OSError):
                 was = None   # unreadable old profile: still fine to replace
         profile = {"name": args.name, "saved": util.now_iso(), "user": util.user(),
                    "skills": {n: {"tap": e.get("tap", "local"),
                                   "version": e.get("version", "0.0.0")}
                               for n, e in installed.items()}}
         paths.ensure_dirs()
-        _profile_path(args.name).write_text(json.dumps(profile, indent=2) + "\n", encoding="utf-8")
+        path.write_text(json.dumps(profile, indent=2) + "\n", encoding="utf-8")
         journal.log("profile", args.name, op="save", skills=len(installed))
         if was is not None:
             out.ok("updated profile %s (was %d skill%s, now %d skill%s)"
@@ -357,13 +363,14 @@ def cmd_profile(argv) -> int:
         return 0
 
     if args.action == "delete":
-        if not _profile_path(args.name).exists():
+        path = _profile_path(args.name)
+        if not path.exists():
             raise BoostError("no profile named %s" % args.name,
                             hint="list profiles with `boost profile list`")
         if not out.confirm("delete profile %s?" % args.name):
             out.info("cancelled")
             return 1
-        _profile_path(args.name).unlink()
+        path.unlink()
         journal.log("profile", args.name, op="delete")
         out.ok("deleted profile %s" % args.name)
         return 0

boost_skill_cli-1.2.97/boost_cli/core/archive.py

@@ -0,0 +1,79 @@
+# Copyright the boost contributors.
+# SPDX-License-Identifier: Apache-2.0
+"""Archive-format helpers for `boost export`.
+
+Kept out of commands/pkg.py (thin CLI glue) so the mutation gate, which only
+targets boost_cli/core, covers the format-inference and member-normalization
+logic `boost export` depends on.
+"""
+from __future__ import annotations
+
+import stat
+import tarfile
+import zipfile
+from pathlib import Path
+
+
+def resolve_export_format(out_path: str | None, zip_flag: bool) -> tuple[bool, str | None]:
+    """Decide zip vs. tar.gz for `boost export` from `--zip` and `-o`'s suffix.
+
+    `--zip` alone used to decide the archive format even when `-o` named a
+    contradicting extension: `-o x.zip` with no `--zip` wrote a gzip tarball
+    named `.zip` (and file(1) called it exactly that), with no warning either
+    way. When `--zip` is absent, a recognized extension on `out_path`
+    (`.zip`, or `.tar.gz`/`.tgz`) now decides the format instead. When
+    `--zip` is given, it still wins — an explicit flag is not silently
+    overridden by a filename — but a recognized extension that contradicts it
+    produces a warning naming what will actually be written. An unrecognized
+    extension (or no `-o` at all) leaves `zip_flag` as the only signal.
+
+    Returns ``(use_zip, warning)``; ``warning`` is ``None`` when nothing needs
+    saying.
+    """
+    if not out_path:
+        return zip_flag, None
+    name = Path(out_path).name.lower()
+    is_zip_suffix = name.endswith(".zip")
+    is_tar_suffix = name.endswith((".tar.gz", ".tgz"))
+    if zip_flag:
+        if is_tar_suffix:
+            return True, ("%s looks like a tar archive but --zip was passed — "
+                          "writing a .zip anyway" % out_path)
+        return True, None
+    if is_zip_suffix:
+        return True, None
+    return False, None
+
+
+def normalize_tar_member(tarinfo: tarfile.TarInfo) -> tarfile.TarInfo:
+    """`tarfile.add` filter: zero uid/gid, blank uname/gname on every member.
+
+    `tarfile.add`'s default filter copies the real filesystem owner onto each
+    member, so an export built as one user and extracted as root left a
+    root-owned Boostfile (built from a bare `TarInfo`, uid/gid 0 and
+    uname/gname "" by construction) sitting beside user-owned skill files —
+    and leaked the builder's username into every archive along the way.
+    Applying this to every member, the hand-built Boostfile included, makes
+    `boost export`'s tar archives deterministic and free of local-account
+    metadata.
+    """
+    tarinfo.uid = 0
+    tarinfo.gid = 0
+    tarinfo.uname = ""
+    tarinfo.gname = ""
+    return tarinfo
+
+
+def boostfile_zipinfo(date_time: tuple[int, int, int, int, int, int]) -> zipfile.ZipInfo:
+    """`ZipInfo` for a zip export's Boostfile member, mode 0o644 not 0o600.
+
+    `ZipFile.writestr` given a bare member name (as `boost export` used to
+    pass) builds its own `ZipInfo` internally, and leaves `external_attr` at
+    the zipfile module's default of `0o600 << 16` — inconsistent with the
+    0o644 skill files `ZipFile.write` adds alongside it from their real disk
+    permissions in the same archive.
+    """
+    zi = zipfile.ZipInfo("Boostfile", date_time)
+    zi.compress_type = zipfile.ZIP_DEFLATED
+    zi.external_attr = (0o644 | stat.S_IFREG) << 16
+    return zi

{boost_skill_cli-1.2.96 → boost_skill_cli-1.2.97}/boost_cli/core/browse.py

@@ -265,6 +265,38 @@ def _similar(a: str, b: str, threshold: float) -> bool:
             and sm.ratio() >= threshold)
 
 
+#: Kinds broken out by name in :func:`plain_footer`, in the order they're
+#: listed. Anything else (there is no fourth kind today, but a cache entry
+#: can carry a stale or missing one) still counts toward the total.
+_PLAIN_KINDS = ("skill", "rule", "workflow")
+
+
+def plain_footer(entries) -> str:
+    """Footer text for the non-interactive browse fallback: total row count,
+    broken down by kind — e.g. ``"128 items: 100 skills · 20 rules · 8
+    workflows"``.
+
+    ``entries`` is what the caller is actually about to show (already
+    deduped, already filtered): this describes the rows on screen, not the
+    catalog behind them. A kind outside :data:`_PLAIN_KINDS` still counts
+    toward the total under "other" rather than silently vanishing from it —
+    the same "never let a count go unexplained" rule the TUI's own footer
+    (:func:`count_tail`) follows.
+    """
+    counts: dict[str, int] = {}
+    for e in entries:
+        kind = str(e.get("kind") or "skill")
+        counts[kind] = counts.get(kind, 0) + 1
+    parts = ["%d %s%s" % (counts[k], k, "" if counts[k] == 1 else "s")
+             for k in _PLAIN_KINDS if counts.get(k)]
+    other = sum(n for k, n in counts.items() if k not in _PLAIN_KINDS)
+    if other:
+        parts.append("%d other%s" % (other, "" if other == 1 else "s"))
+    n = len(entries)
+    return "%d item%s: %s" % (n, "" if n == 1 else "s",
+                              " · ".join(parts) if parts else "none")
+
+
 # --------------------------------------------------------------- focus
 
 #: Panes the focus ring can hold, top to bottom as the user reads them.