boost-skill-cli 1.0.251__tar.gz → 1.0.253__tar.gz

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/PKG-INFO

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

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/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.251'
-__version_tuple__ = version_tuple = (1, 0, 251)
+__version__ = version = '1.0.253'
+__version_tuple__ = version_tuple = (1, 0, 253)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_cli/commands/configuration.py

@@ -2,6 +2,7 @@
 completions, schedule, serve, mcp, self-update."""
 from __future__ import annotations
 
+import argparse
 import json
 import os
 import re
@@ -401,8 +402,41 @@ jobs:
 """
 
 
+def _write_onboard_file(dest: Path, content: str, force: bool) -> bool:
+    """Write one generated onboard file; confirm first if it already exists.
+
+    ``boost onboard`` is routinely re-run on a repo that already has its own
+    tracked ``.skill-lock.json``, and a bare ``write_text`` there replaces the
+    repo's lock with whatever this machine happens to have installed — while
+    still reporting "created". Existence has to be checked *before* the write,
+    the same way :func:`intelligence._write_generated` already does.
+
+    Returns True when the file was written.
+    """
+    if not dest.exists():
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, encoding="utf-8")
+        out.ok("created %s" % _tilde(dest))
+        return True
+    try:
+        unchanged = dest.read_text(encoding="utf-8") == content
+    except (OSError, UnicodeDecodeError):
+        unchanged = False   # unreadable: treat as different and ask
+    if unchanged:
+        # Re-running onboard regenerates the workflow byte-for-byte. Prompting
+        # to overwrite a file with its own contents is noise, not safety.
+        out.info("unchanged %s" % _tilde(dest))
+        return False
+    if not force and not out.confirm("overwrite %s?" % _tilde(dest)):
+        out.info("skipped %s" % _tilde(dest))
+        return False
+    dest.write_text(content, encoding="utf-8")
+    out.ok("updated %s" % _tilde(dest))
+    return True
+
+
 def cmd_onboard(argv) -> int:
-    """boost onboard [--repo DIR] [--pr] [--dry-run]"""
+    """boost onboard [--repo DIR] [--pr] [--dry-run] [--force]"""
     p = cliparse.parser(
         prog="boost onboard",
         description="Add skill-tracker telemetry to a repo & open a PR")
@@ -411,6 +445,9 @@ def cmd_onboard(argv) -> int:
                    help="commit on a branch and open a PR with `gh`")
     p.add_argument("--dry-run", action="store_true",
                    help="preview the files without writing anything")
+    p.add_argument("-f", "--force", action="store_true",
+                   help="overwrite existing files without confirming")
+    p.add_argument("-y", "--yes", action="store_true", help=argparse.SUPPRESS)
     args = p.parse_args(argv)
 
     repo = paths.expand(args.repo).resolve()
@@ -431,7 +468,10 @@ def cmd_onboard(argv) -> int:
 
     if args.dry_run:
         for rel, content in files:
-            out.heading("would write %s" % _tilde(repo / rel))
+            dest = repo / rel
+            out.heading("would %s %s"
+                        % ("overwrite" if dest.exists() else "write",
+                           _tilde(dest)))
             for line in content.splitlines()[:24]:
                 out.dim("    " + line)
         return 0
@@ -447,17 +487,21 @@ def cmd_onboard(argv) -> int:
             raise BoostError("the `gh` CLI is required for --pr",
                             hint="brew install gh, or rerun without --pr")
 
-    for rel, content in files:
-        fp = repo / rel
-        fp.parent.mkdir(parents=True, exist_ok=True)
-        fp.write_text(content, encoding="utf-8")
-        out.ok("created %s" % _tilde(fp))
+    written = [rel for rel, content in files
+               if _write_onboard_file(repo / rel, content,
+                                      args.force or args.yes)]
+    if not written:
+        # Nothing changed, so there is nothing to journal — and nothing for
+        # --pr to commit. Branching here would leave an empty branch behind
+        # and then fail on `git commit` with no staged changes.
+        out.info("nothing to do — %s already onboarded" % _tilde(repo))
+        return 0
     journal.log("onboard", _tilde(repo), pr=args.pr or None)
 
     if args.pr:
         branch = "boost/onboard-skill-tracker"
         gitutil.run(["-C", str(repo), "checkout", "-b", branch])
-        gitutil.run(["-C", str(repo), "add"] + [rel for rel, _ in files])
+        gitutil.run(["-C", str(repo), "add", *written])
         gitutil.run(["-C", str(repo), "commit", "-m",
                      "chore: add boost skill tracking (boost onboard)"])
         try:

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_cli/commands/discovery.py

@@ -5,7 +5,6 @@ Also exports detect_stack(), shared with the Quality commands.
 """
 from __future__ import annotations
 
-import argparse
 import contextlib
 import json
 import operator
@@ -40,17 +39,6 @@ from ..errors import BoostError
 __all__ = ["detect_stack"]
 
 
-def _positive_int(s: str) -> int:
-    """argparse type for --limit flags: an int that must be >= 1."""
-    try:
-        v = int(s)
-    except ValueError:
-        raise argparse.ArgumentTypeError("invalid int value: %r" % s) from None
-    if v < 1:
-        raise argparse.ArgumentTypeError("must be >= 1")
-    return v
-
-
 _tilde = paths.tilde
 
 
@@ -98,7 +86,7 @@ def cmd_search(argv):
     p.add_argument("query", nargs="+", help="search terms")
     p.add_argument("--smart", action="store_true",
                    help="rerank the top hits with Claude")
-    p.add_argument("--limit", type=_positive_int, default=15,
+    p.add_argument("--limit", type=util.positive_int, default=15,
                    help="max results (default 15)")
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
@@ -223,7 +211,7 @@ def cmd_index(argv):
     p = cliparse.parser(
         prog="boost index",
         description="Build the discovery registry via GitHub Code Search")
-    p.add_argument("--limit", type=_positive_int, default=300,
+    p.add_argument("--limit", type=util.positive_int, default=300,
                    help="max skill files to index (default 300)")
     args = p.parse_args(argv)
     if not shutil.which("gh"):
@@ -329,7 +317,7 @@ def cmd_discover(argv):
         prog="boost discover",
         description="Browse & search the GitHub-wide skill discovery index")
     p.add_argument("query", nargs="*", help="filter terms (repo/path substring)")
-    p.add_argument("--limit", type=_positive_int, default=25,
+    p.add_argument("--limit", type=util.positive_int, default=25,
                    help="max rows (default 25)")
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
@@ -398,7 +386,7 @@ def cmd_recommend(argv):
         prog="boost recommend",
         description="Suggest skills based on your project's tech stack")
     p.add_argument("--path", default=".", help="project directory (default: cwd)")
-    p.add_argument("--limit", type=_positive_int, default=8,
+    p.add_argument("--limit", type=util.positive_int, default=8,
                    help="max suggestions (default 8)")
     p.add_argument("--json", action="store_true", dest="as_json",
                    help="machine-readable output")
@@ -885,7 +873,7 @@ def cmd_trending(argv):
     p = cliparse.parser(
         prog="boost trending",
         description="Show trending skills by install count")
-    p.add_argument("--limit", type=_positive_int, default=10,
+    p.add_argument("--limit", type=util.positive_int, default=10,
                    help="max rows (default 10)")
     args = p.parse_args(argv)
     evs = journal.events(action="install")

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_cli/commands/info.py

@@ -575,7 +575,7 @@ def cmd_log(argv):
     ap = cliparse.parser(prog="boost log",
                                  description="Git log for a skill, or boost's activity log")
     ap.add_argument("name", nargs="?", help="skill to show upstream history for")
-    ap.add_argument("-n", "--limit", type=int, default=20, metavar="N",
+    ap.add_argument("-n", "--limit", type=util.positive_int, default=20, metavar="N",
                     help="max entries (default 20)")
     ap.add_argument("--diagnostics", action="store_true",
                     help="show boost's diagnostic log trail (not skill history)")

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_cli/commands/team.py

@@ -456,7 +456,8 @@ def cmd_pulse(argv) -> int:
     p = cliparse.parser(
         prog="boost pulse",
         description="Team activity feed of skill-management events")
-    p.add_argument("-n", type=int, default=20, help="events to show (default 20)")
+    p.add_argument("-n", type=util.positive_int, default=20,
+                   help="events to show (default 20)")
     p.add_argument("--all", action="store_true", help="show the whole journal")
     p.add_argument("--action", help="filter by action (install, tap, ...)")
     p.add_argument("--json", action="store_true", help="machine-readable output")

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_cli/core/journal.py

@@ -30,7 +30,13 @@ def log(action: str, subject: str = "", **fields) -> None:
 
 def events(n: Optional[int] = None, action: Optional[str] = None,
            subject: Optional[str] = None) -> List[dict]:
-    """Most-recent-first list of journal events."""
+    """Most-recent-first list of journal events; ``n=None`` means all of them.
+
+    ``n`` must be >= 0: a negative would become a negative slice and silently
+    return every event *but* the oldest ones, so it raises instead.
+    """
+    if n is not None and n < 0:
+        raise ValueError("events(n=%d): n must be >= 0" % n)
     p = paths.pulse_path()
     if not p.exists():
         return []
@@ -48,7 +54,7 @@ def events(n: Optional[int] = None, action: Optional[str] = None,
             continue
         out.append(e)
     out.reverse()
-    return out[:n] if n else out
+    return out if n is None else out[:n]
 
 
 def _line_count(p) -> int:

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_cli/core/util.py

@@ -119,6 +119,28 @@ def atomic_write_text(path: Path, text: str, encoding: str = "utf-8") -> None:
         raise
 
 
+def positive_int(s: str) -> int:
+    """argparse ``type=`` for count flags (``-n``/``--limit``): an int >= 1.
+
+    A bare ``type=int`` lets a negative through, and every count flag in boost
+    ends up as a slice bound or a ``git log -n`` argument — where a negative
+    silently *inverts* the request instead of failing it. Rejecting it at parse
+    time is the only place the user still sees a usable error.
+    """
+    # Local import: argparse is not on the `boost --help` startup path, and
+    # util is (via core.logs). Every caller of this function is a command
+    # module that has already imported argparse through cliparse.
+    import argparse
+
+    try:
+        v = int(s)
+    except (TypeError, ValueError):
+        raise argparse.ArgumentTypeError("invalid int value: %r" % s) from None
+    if v < 1:
+        raise argparse.ArgumentTypeError("must be >= 1")
+    return v
+
+
 def now_iso() -> str:
     """Return UTC now as ``'2026-07-16T01:00:00Z'`` (what ``rel_time`` parses)."""
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/docs/commands.html

@@ -181,7 +181,7 @@
       <a class="cmd-link" href="#cmd-clean" data-search="clean clear stale caches &amp; broken symlinks  --dry-run --deep">clean</a>
       <a class="cmd-link" href="#cmd-create" data-search="create scaffold a new skill from a template  --description description --dir dir --install name">create</a>
       <a class="cmd-link" href="#cmd-policy" data-search="policy manage &amp; enforce skill governance policies  --json {list,set,unset,check} key value">policy</a>
-      <a class="cmd-link" href="#cmd-onboard" data-search="onboard add skill-tracker telemetry to a repo &amp; open a pr  --repo repo --pr --dry-run">onboard</a>
+      <a class="cmd-link" href="#cmd-onboard" data-search="onboard add skill-tracker telemetry to a repo &amp; open a pr  --repo repo --pr --dry-run -f, --force">onboard</a>
       <a class="cmd-link" href="#cmd-completions" data-search="completions generate shell tab-completion scripts  {bash,zsh,fish}">completions</a>
       <a class="cmd-link" href="#cmd-schedule" data-search="schedule manage automatic skill-sync scheduling  --interval {6h,12h,daily} --json {status,enable,disable}">schedule</a>
       <a class="cmd-link" href="#cmd-serve" data-search="serve serve the skill catalog over http (port 8787)  --port port --host host">serve</a>
@@ -991,15 +991,16 @@
           <div class="arg"><code>--json</code><span>machine-readable output</span></div>
         </div>
       </section>
-      <section class="cmd" id="cmd-onboard" data-search="onboard add skill-tracker telemetry to a repo &amp; open a pr  --repo repo --pr --dry-run">
+      <section class="cmd" id="cmd-onboard" data-search="onboard add skill-tracker telemetry to a repo &amp; open a pr  --repo repo --pr --dry-run -f, --force">
         <h3><span class="cname">onboard</span><span class="gtag">cfg</span></h3>
         <p class="summary">Add skill-tracker telemetry to a repo &amp; open a PR</p>
-        <pre class="syn">boost onboard [--repo REPO] [--pr] [--dry-run]</pre>
+        <pre class="syn">boost onboard [--repo REPO] [--pr] [--dry-run] [--force]</pre>
         <div class="args-h">Options</div>
         <div class="args">
           <div class="arg"><code>--repo REPO</code><span>repository directory (default: .)</span></div>
           <div class="arg"><code>--pr</code><span>commit on a branch and open a PR with `gh`</span></div>
           <div class="arg"><code>--dry-run</code><span>preview the files without writing anything</span></div>
+          <div class="arg"><code>-f, --force</code><span>overwrite existing files without confirming</span></div>
         </div>
       </section>
       <section class="cmd" id="cmd-completions" data-search="completions generate shell tab-completion scripts  {bash,zsh,fish}">

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/tests/functional/test_cli_configuration.py

@@ -345,6 +345,154 @@ class TestOnboard:
         assert "is not clean" in r.err
 
 
+class TestOnboardOverwrite:
+    """Re-running onboard must not silently replace a repo's own files.
+
+    The interesting file is ``.skill-lock.json``: a repo that tracks its own
+    lock gets it replaced by whatever *this machine* has installed, and the
+    old code still printed "created". Every test here therefore asserts on
+    file contents, not just on the message.
+    """
+
+    LOCK = ".skill-lock.json"
+    TELEMETRY = ".boost/telemetry.json"
+    WORKFLOW = ".github/workflows/boost-skill-inventory.yml"
+
+    def _seeded(self, boost, tmp_path):
+        """A repo already onboarded, with a hand-edited lock file."""
+        repo = tmp_path / "repo"
+        repo.mkdir()
+        boost("onboard", "--repo", repo)             # BOOST_ASSUME_YES: creates
+        (repo / self.LOCK).write_text('{"mine": true}\n', encoding="utf-8")
+        return repo
+
+    def test_declining_leaves_the_existing_file_byte_for_byte(
+            self, boost, installed, tmp_path, monkeypatch):
+        repo = self._seeded(boost, tmp_path)
+        monkeypatch.delenv("BOOST_ASSUME_YES")   # stdin is not a tty -> "no"
+        r = boost("onboard", "--repo", repo)
+        assert (repo / self.LOCK).read_text(encoding="utf-8") == '{"mine": true}\n'
+        assert "skipped" in r.out
+        assert "created %s" % self.LOCK not in r.out
+
+    def test_force_overwrites_and_says_updated_not_created(
+            self, boost, installed, tmp_path, monkeypatch):
+        repo = self._seeded(boost, tmp_path)
+        monkeypatch.delenv("BOOST_ASSUME_YES")
+        r = boost("onboard", "--repo", repo, "--force")
+        lock = json.loads((repo / self.LOCK).read_text(encoding="utf-8"))
+        assert "brainstorming" in lock["skills"], "the real lock, not the stub"
+        assert "updated" in r.out
+        # "created" was the lie the old code told about every overwrite.
+        assert "created" not in r.out
+
+    def test_answering_yes_at_the_prompt_overwrites(
+            self, boost, installed, tmp_path):
+        # BOOST_ASSUME_YES is the fixture default, i.e. the user said yes.
+        repo = self._seeded(boost, tmp_path)
+        r = boost("onboard", "--repo", repo)
+        lock = json.loads((repo / self.LOCK).read_text(encoding="utf-8"))
+        assert "brainstorming" in lock["skills"]
+        assert "updated" in r.out
+
+    def test_an_existing_file_boost_cannot_read_is_still_protected(
+            self, boost, installed, tmp_path, monkeypatch):
+        # The identical-content shortcut reads the file; a binary or
+        # permission-denied file must fall back to asking, not to overwriting.
+        repo = self._seeded(boost, tmp_path)
+        (repo / self.WORKFLOW).write_bytes(b"\xff\xfe not utf-8")
+        monkeypatch.delenv("BOOST_ASSUME_YES")
+        r = boost("onboard", "--repo", repo)
+        assert (repo / self.WORKFLOW).read_bytes() == b"\xff\xfe not utf-8"
+        assert "skipped" in r.out
+
+    def test_the_hidden_yes_alias_also_overwrites(
+            self, boost, installed, tmp_path, monkeypatch):
+        repo = self._seeded(boost, tmp_path)
+        monkeypatch.delenv("BOOST_ASSUME_YES")
+        boost("onboard", "--repo", repo, "--yes")
+        assert '{"mine": true}' not in (repo / self.LOCK).read_text(encoding="utf-8")
+
+    def test_identical_content_is_never_prompted_for(
+            self, boost, installed, tmp_path, monkeypatch):
+        # The workflow YAML regenerates byte-for-byte, so a second run has
+        # nothing to ask about it. Asking anyway trains users to say yes.
+        repo = self._seeded(boost, tmp_path)
+        # Leave *only* the workflow: telemetry carries a timestamp and the lock
+        # is live machine state, so neither is a stable "identical" case.
+        (repo / self.TELEMETRY).unlink()
+        (repo / self.LOCK).unlink()
+        monkeypatch.delenv("BOOST_ASSUME_YES")
+        monkeypatch.setattr("boost_cli.core.output.confirm",
+                            lambda *a, **k: pytest.fail(
+                                "prompted to overwrite an identical file"))
+        r = boost("onboard", "--repo", repo)
+        assert "unchanged" in r.out
+        assert self.WORKFLOW in r.out
+
+    def test_dry_run_distinguishes_write_from_overwrite(
+            self, boost, installed, tmp_path):
+        repo = self._seeded(boost, tmp_path)
+        r = boost("onboard", "--repo", repo, "--dry-run")
+        assert "would overwrite" in r.out
+        assert "would write" not in r.out, "every file already exists here"
+        assert (repo / self.LOCK).read_text(encoding="utf-8") == '{"mine": true}\n'
+
+    def test_declining_everything_journals_nothing(
+            self, boost, installed, tmp_path, monkeypatch):
+        repo = self._seeded(boost, tmp_path)
+        # Make all three differ so all three get a prompt, then decline them.
+        (repo / self.TELEMETRY).write_text("{}\n", encoding="utf-8")
+        (repo / self.WORKFLOW).write_text("# theirs\n", encoding="utf-8")
+        before = len(journal.events(action="onboard"))
+        monkeypatch.delenv("BOOST_ASSUME_YES")
+        r = boost("onboard", "--repo", repo)
+        assert "nothing to do" in r.out
+        assert len(journal.events(action="onboard")) == before, \
+            "a no-op run must not add an onboard event"
+
+    def test_pr_stages_only_the_files_it_actually_wrote(
+            self, boost, installed, tmp_path, monkeypatch):
+        repo = _mk_repo(tmp_path / "repo")
+        (repo / self.LOCK).write_text('{"mine": true}\n', encoding="utf-8")
+        _git(repo, "add", "-A")
+        _git(repo, "commit", "-qm", "our own lock")
+        monkeypatch.setattr("boost_cli.commands.configuration.shutil.which",
+                            lambda c: "/usr/bin/" + c)
+        real_run = subprocess.run
+        monkeypatch.setattr(
+            "boost_cli.commands.configuration.subprocess.run",
+            lambda cmd, **kw: _proc(cmd, 0, out="https://github.com/o/r/pull/9\n")
+            if cmd and cmd[0] == "gh" else real_run(cmd, **kw))
+        monkeypatch.delenv("BOOST_ASSUME_YES")     # decline the lock overwrite
+        boost("onboard", "--repo", repo, "--pr")
+
+        names = subprocess.run(["git", "show", "--name-only", "--pretty=", "HEAD"],
+                               cwd=str(repo), capture_output=True, text=True)
+        staged = set(names.stdout.split())
+        assert staged == {self.TELEMETRY, self.WORKFLOW}
+        assert (repo / self.LOCK).read_text(encoding="utf-8") == '{"mine": true}\n'
+
+    def test_pr_with_nothing_to_write_leaves_no_branch_behind(
+            self, boost, installed, tmp_path, monkeypatch):
+        repo = _mk_repo(tmp_path / "repo")
+        for rel, body in ((self.TELEMETRY, "{}\n"), (self.WORKFLOW, "# theirs\n"),
+                          (self.LOCK, '{"mine": true}\n')):
+            (repo / rel).parent.mkdir(parents=True, exist_ok=True)
+            (repo / rel).write_text(body, encoding="utf-8")
+        _git(repo, "add", "-A")
+        _git(repo, "commit", "-qm", "already ours")
+        monkeypatch.setattr("boost_cli.commands.configuration.shutil.which",
+                            lambda c: "/usr/bin/" + c)
+        monkeypatch.delenv("BOOST_ASSUME_YES")
+        r = boost("onboard", "--repo", repo, "--pr")
+        assert "nothing to do" in r.out
+        head = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                              cwd=str(repo), capture_output=True, text=True)
+        assert head.stdout.strip() != "boost/onboard-skill-tracker", \
+            "an empty branch would fail on `git commit` with nothing staged"
+
+
 # ---------------------------------------------------------------- completions
 
 class TestCompletions:

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/tests/functional/test_cli_info.py

@@ -314,6 +314,11 @@ class TestLog:
         assert len(lines) == 1
         assert "install brainstorming" in lines[0]
 
+    def test_negative_limit_rejected_on_every_branch(self, boost, installed):
+        for extra in ([], ["--diagnostics"], ["--crashes"]):
+            r = boost("log", *extra, "-n", "-1", expect=2)
+            assert "argument -n/--limit: must be >= 1" in r.err
+
     def test_skill_git_history(self, boost, installed):
         r = boost("log", "brainstorming")
         assert "brainstorming — history in fixture-tap" in r.out

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/tests/functional/test_cli_team.py

@@ -324,6 +324,12 @@ class TestPulse:
         rows = [l for l in r.out.splitlines() if USER in l]
         assert len(rows) == 1 and "fixture-tap" in rows[0]
 
+    def test_negative_or_zero_limit_rejected(self, boost, installed):
+        r = boost("pulse", "-n", "-1", expect=2)
+        assert "argument -n: must be >= 1" in r.err
+        r = boost("pulse", "-n", "0", expect=2)
+        assert "argument -n: must be >= 1" in r.err
+
     def test_json_purity(self, boost, installed):
         r = boost("pulse", "--json")
         events = json.loads(r.out)

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/tests/unit/test_journal.py

@@ -5,6 +5,8 @@ import getpass
 import json
 import re
 
+import pytest
+
 from boost_cli.core import journal, paths
 
 
@@ -254,3 +256,24 @@ class TestRotationHealthy:
     def test_one_over_limit_unhealthy(self, sandbox):
         write_lines(journal.ROTATE_AT + 1)
         assert journal.rotation_healthy() is False
+
+
+class TestEventsLimitGuard:
+    """A negative n used to become a negative slice — see the roadmap item."""
+
+    def test_negative_n_raises_instead_of_inverting(self, sandbox):
+        for i in range(3):
+            journal.log("install", "s%d" % i)
+        with pytest.raises(ValueError) as exc:
+            journal.events(-1)
+        assert str(exc.value) == "events(n=-1): n must be >= 0"
+        assert len(journal.events()) == 3
+
+    def test_zero_n_is_empty_not_everything(self, sandbox):
+        for i in range(3):
+            journal.log("install", "s%d" % i)
+        assert journal.events(0) == []
+
+    def test_n_larger_than_feed_returns_all(self, sandbox):
+        journal.log("install", "only")
+        assert [e["subject"] for e in journal.events(9)] == ["only"]

{boost_skill_cli-1.0.251 → boost_skill_cli-1.0.253}/tests/unit/test_util.py

@@ -1,6 +1,7 @@
 """Unit tests: boost_cli/core/util.py — time, hashing, versions, scoring."""
 from __future__ import annotations
 
+import argparse
 import hashlib
 import re
 import time
@@ -635,3 +636,26 @@ class TestSafeComponent:
         # parent directory itself.
         assert util.safe_component("..") == "skill"
         assert util.safe_component(".") == "skill"
+
+
+class TestPositiveInt:
+    """`util.positive_int` — the argparse type behind every -n/--limit flag."""
+
+    def test_accepts_one_and_above_exactly(self):
+        assert util.positive_int("1") == 1
+        assert util.positive_int("20") == 20
+
+    def test_zero_rejected_with_exact_message(self):
+        with pytest.raises(argparse.ArgumentTypeError) as exc:
+            util.positive_int("0")
+        assert str(exc.value) == "must be >= 1"
+
+    def test_negative_rejected_with_exact_message(self):
+        with pytest.raises(argparse.ArgumentTypeError) as exc:
+            util.positive_int("-1")
+        assert str(exc.value) == "must be >= 1"
+
+    def test_non_numeric_rejected_with_exact_message(self):
+        with pytest.raises(argparse.ArgumentTypeError) as exc:
+            util.positive_int("abc")
+        assert str(exc.value) == "invalid int value: 'abc'"