boost-skill-cli 1.0.92__tar.gz → 1.0.93__tar.gz

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/PKG-INFO

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

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/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.92'
-__version_tuple__ = version_tuple = (1, 0, 92)
+__version__ = version = '1.0.93'
+__version_tuple__ = version_tuple = (1, 0, 93)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/boost_cli/commands/pkg.py

@@ -16,7 +16,7 @@ from typing import Dict, List, Optional
 
 from .. import cliparse
 from ..core import (agents, catalog, gitutil, journal, lockfile, paths,
-                    registry, staleness, store, util)
+                    registry, staleness, store, typosquat, util)
 from ..core import output as out
 from ..errors import BoostError
 
@@ -35,6 +35,23 @@ def _plural(n: int, word: str) -> str:
     return "%d %s%s" % (n, word, "" if n == 1 else "s")
 
 
+def _warn_confusions(entries: List[dict]) -> None:
+    """Warn when a skill about to be installed is confusable with one from a
+    *different* tap — the typosquat / owner-confusion guard (core.typosquat).
+
+    Quiet by default: it only speaks up when a near-identical name resolves to
+    another owner, which is exactly the fat-finger-into-a-look-alike case.
+    """
+    if not entries:
+        return
+    all_entries = catalog.all_entries()
+    for e in entries:
+        for other in typosquat.find_confusions(e, all_entries)[:3]:
+            out.warn("%s (%s) closely resembles %s (%s) — double-check you "
+                     "meant this one" % (e["name"], e["tap"],
+                                         other["name"], other["tap"]))
+
+
 def _check_agents(names: Optional[List[str]]) -> Optional[List[str]]:
     """Validate --agent values against configured agents."""
     if not names:
@@ -106,6 +123,8 @@ def cmd_install(argv: List[str]) -> int:
             out.warn("%s: %s" % (n, err.message))
             failed += 1
 
+    _warn_confusions(entries)
+
     if args.dry_run:
         targets = [a for a in agents.enabled_agents() if not only or a in only]
         for e in entries:

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/boost_cli/core/logs.py

@@ -36,6 +36,7 @@ import logging.handlers
 import os
 import platform
 import sys
+import time
 import traceback
 from datetime import datetime, timezone
 from pathlib import Path
@@ -143,6 +144,10 @@ def configure(verbose: bool = False, debug: bool = False,
         "%(asctime)s %(levelname)-7s %(name)s: %(message)s",
         datefmt="%Y-%m-%dT%H:%M:%SZ",
     )
+    # datefmt stamps a literal ``Z`` (UTC) suffix, so the timestamp must be
+    # rendered in UTC — otherwise ``%(asctime)s`` uses local time and every
+    # line is mislabelled by the machine's offset. gmtime keeps it honest.
+    fmt.converter = time.gmtime
 
     # File handler — always DEBUG, best-effort (never break the CLI over a log).
     if _file_enabled():

boost_skill_cli-1.0.93/boost_cli/core/typosquat.py

@@ -0,0 +1,85 @@
+"""Detect typosquatted / confusable skill names (stdlib only).
+
+The classic package-manager attack is a skill named one keystroke away from a
+popular one, or a familiar name that quietly resolves to a *different*
+owner/repo. These helpers measure how close two names are and flag catalog
+entries that are suspiciously similar to — but not the same source as — the one
+a user asked for, so a command can warn before installing a look-alike.
+"""
+from __future__ import annotations
+
+from typing import List
+
+
+def edit_distance(a: str, b: str, cap: int = 2) -> int:
+    """Levenshtein distance between ``a`` and ``b``, not measured past ``cap``.
+
+    Returns the true distance when it is ``<= cap``, otherwise ``cap + 1`` — a
+    sentinel meaning "farther apart than we care about". The row-minimum
+    early-exit keeps a comparison against a large catalog cheap: as soon as an
+    entire DP row exceeds ``cap`` no completion can come back under it.
+    """
+    if a == b:
+        return 0
+    la, lb = len(a), len(b)
+    if abs(la - lb) > cap:            # a length gap alone already exceeds cap
+        return cap + 1
+    if la > lb:                       # iterate over the shorter string's rows
+        a, b, la, lb = b, a, lb, la
+    prev = list(range(lb + 1))
+    for i in range(1, la + 1):
+        cur = [i] + [0] * lb
+        row_min = i
+        ca = a[i - 1]
+        for j in range(1, lb + 1):
+            cost = 0 if ca == b[j - 1] else 1
+            cur[j] = min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost)
+            if cur[j] < row_min:
+                row_min = cur[j]
+        if row_min > cap:
+            return cap + 1
+        prev = cur
+    return prev[lb] if prev[lb] <= cap else cap + 1
+
+
+def confusable_names(name: str, candidates, max_distance: int = 1) -> List[str]:
+    """Candidate names within ``1..max_distance`` edits of ``name``.
+
+    Case-insensitive; exact matches (distance 0) and duplicates are dropped.
+    Ordered by ascending distance, then name, so the closest look-alike is
+    first.
+    """
+    target = name.lower()
+    hits = []
+    seen = set()
+    for cand in candidates:
+        low = cand.lower()
+        if low == target or low in seen:
+            continue
+        d = edit_distance(target, low, max_distance)
+        if 1 <= d <= max_distance:
+            hits.append((d, cand))
+            seen.add(low)
+    hits.sort(key=lambda t: (t[0], t[1]))
+    return [c for _d, c in hits]
+
+
+def find_confusions(target: dict, entries, max_distance: int = 1) -> List[dict]:
+    """Catalog entries that are confusable with ``target`` but from another tap.
+
+    Flags both the owner-confusion case (same name, *different* tap → distance
+    0) and the typosquat case (name within ``max_distance`` edits, different
+    tap). Entries from ``target``'s own tap are never flagged, and ``target``
+    itself is excluded by identity. Sorted by ``(distance, name, tap)``.
+    """
+    tname = str(target.get("name", "")).lower()
+    ttap = target.get("tap")
+    scored = []
+    for e in entries:
+        if e is target or e.get("tap") == ttap:
+            continue
+        d = edit_distance(tname, str(e.get("name", "")).lower(), max_distance)
+        if d <= max_distance:
+            scored.append((d, e))
+    scored.sort(key=lambda t: (t[0], str(t[1].get("name")), str(t[1].get("tap"))))
+    return [e for _d, e in scored]

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/boost_skill_cli.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ boost_cli/core/rag.py
 boost_cli/core/registry.py
 boost_cli/core/staleness.py
 boost_cli/core/store.py
+boost_cli/core/typosquat.py
 boost_cli/core/util.py
 boost_cli/data/registries.json
 boost_skill_cli.egg-info/PKG-INFO
@@ -222,6 +223,7 @@ tests/unit/test_mcp.py
 tests/unit/test_mutation_hardening.py
 tests/unit/test_output.py
 tests/unit/test_paths.py
+tests/unit/test_pkg_confusions.py
 tests/unit/test_policy.py
 tests/unit/test_rag.py
 tests/unit/test_registries_fresh.py
@@ -231,5 +233,6 @@ tests/unit/test_spin.py
 tests/unit/test_staleness.py
 tests/unit/test_store.py
 tests/unit/test_token_parity.py
+tests/unit/test_typosquat.py
 tests/unit/test_util.py
 tests/unit/test_version.py

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/docs/roadmap/items/log-timestamps-mislabeled-utc.md

@@ -2,15 +2,15 @@
 id: log-timestamps-mislabeled-utc
 board: code
 section: health
-status: planned
+status: shipped
 category: Observability · Diagnostics
 complexity: S
 impact: Med
 wow: 2
 note: converter = time.gmtime
 order: 10
-owner:
-pr:
+owner: loop/utc-log-timestamps
+pr: 104
 title: Log timestamps are local time mislabeled <code>Z</code>
 ---
 <code>core/logs.py</code> builds the <code>logging.Formatter</code> with

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/docs/roadmap/items/typosquat-and-name-confusion-detection.md

@@ -2,15 +2,15 @@
 id: typosquat-and-name-confusion-detection
 board: code
 section: trust
-status: planned
+status: shipped
 category: Security · Registry
 complexity: M
 impact: Med
 wow: 4
 note: edit-distance guard
 order: 4
-owner:
-pr:
+owner: loop/typosquat-detect
+pr: 107
 title: Typosquat & name-confusion detection
 ---
 The classic package-manager attack: a skill named one edit-distance from

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/docs/roadmap.html

@@ -836,7 +836,7 @@
       </article>
 
       <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Observability · Diagnostics</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Observability · Diagnostics</span></div>
         <h3>Log timestamps are local time mislabeled <code>Z</code></h3>
         <p><code>core/logs.py</code> builds the <code>logging.Formatter</code> with
            <code>datefmt="%Y-%m-%dT%H:%M:%SZ"</code> but never sets
@@ -1560,7 +1560,7 @@ and the work stays visible.</p>
       </article>
 
       <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Security · Registry</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Security · Registry</span></div>
         <h3>Typosquat &amp; name-confusion detection</h3>
         <p>The classic package-manager attack: a skill named one edit-distance from
            a popular one, or a familiar name that quietly resolves to an unexpected

{boost_skill_cli-1.0.92 → boost_skill_cli-1.0.93}/tests/unit/test_logs.py

@@ -2,7 +2,9 @@
 from __future__ import annotations
 
 import logging
+import logging.handlers
 import pathlib
+import time
 
 import pytest
 
@@ -342,3 +344,37 @@ def test_doctor_reports_log_location(boost):
     boost("count")
     res = boost("doctor", expect=None)
     assert "diagnostic log at" in res.out
+
+
+def _file_formatter():
+    """The formatter attached to the configured file handler."""
+    for h in logs.get_logger().handlers:
+        if isinstance(h, logging.handlers.RotatingFileHandler):
+            return h.formatter
+    raise AssertionError("no file handler configured")
+
+
+class TestUtcTimestamps:
+    def test_formatter_uses_gmtime_converter(self, env):
+        # datefmt stamps a literal ``Z`` (UTC) suffix, so the converter MUST be
+        # gmtime; the default (localtime) would mislabel every line.
+        logs.configure()
+        assert _file_formatter().converter is time.gmtime
+
+    def test_asctime_is_utc_regardless_of_local_zone(self, env, monkeypatch):
+        # Force a non-UTC local zone; the rendered stamp must still be UTC.
+        if not hasattr(time, "tzset"):
+            pytest.skip("time.tzset unavailable on this platform")
+        monkeypatch.setenv("TZ", "America/New_York")  # UTC-5/-4, never UTC
+        time.tzset()
+        try:
+            logs.configure()
+            fmt = _file_formatter()
+            record = logging.LogRecord(
+                "boost", logging.INFO, __file__, 1, "msg", None, None
+            )
+            record.created = 0.0  # 1970-01-01T00:00:00Z
+            assert fmt.formatTime(record, fmt.datefmt) == "1970-01-01T00:00:00Z"
+        finally:
+            monkeypatch.delenv("TZ", raising=False)
+            time.tzset()

boost_skill_cli-1.0.93/tests/unit/test_pkg_confusions.py

@@ -0,0 +1,45 @@
+"""Unit tests: pkg._warn_confusions — the install-time typosquat guard wiring."""
+from __future__ import annotations
+
+from boost_cli.commands import pkg
+from boost_cli.core import catalog
+from boost_cli.core import output as out
+
+
+def _capture(monkeypatch, entries):
+    monkeypatch.setattr(catalog, "all_entries", lambda: entries)
+    warnings = []
+    monkeypatch.setattr(out, "warn", lambda m: warnings.append(m))
+    return warnings
+
+
+def test_warns_on_cross_tap_lookalike(monkeypatch):
+    entries = [{"name": "deploy", "tap": "alice/skills"},
+               {"name": "deployy", "tap": "mallory/evil"}]
+    warnings = _capture(monkeypatch, entries)
+    pkg._warn_confusions([entries[0]])
+    assert len(warnings) == 1
+    assert "mallory/evil" in warnings[0] and "deploy" in warnings[0]
+
+
+def test_quiet_when_no_confusion(monkeypatch):
+    entries = [{"name": "deploy", "tap": "alice/skills"},
+               {"name": "totally-unrelated", "tap": "bob/x"}]
+    warnings = _capture(monkeypatch, entries)
+    pkg._warn_confusions([entries[0]])
+    assert warnings == []
+
+
+def test_same_tap_sibling_not_warned(monkeypatch):
+    entries = [{"name": "deploy", "tap": "alice/skills"},
+               {"name": "deployy", "tap": "alice/skills"}]
+    warnings = _capture(monkeypatch, entries)
+    pkg._warn_confusions([entries[0]])
+    assert warnings == []
+
+
+def test_empty_entries_skips_catalog_lookup(monkeypatch):
+    def boom():
+        raise AssertionError("catalog must not be queried for an empty install")
+    monkeypatch.setattr(catalog, "all_entries", boom)
+    pkg._warn_confusions([])  # returns before touching the catalog

boost_skill_cli-1.0.93/tests/unit/test_typosquat.py

@@ -0,0 +1,132 @@
+"""Unit tests: boost_cli/core/typosquat.py — edit distance & name confusion."""
+from __future__ import annotations
+
+from boost_cli.core import typosquat
+
+
+class TestEditDistance:
+    def test_identical_is_zero(self):
+        assert typosquat.edit_distance("brainstorm", "brainstorm") == 0
+
+    def test_single_substitution(self):
+        assert typosquat.edit_distance("cat", "cot") == 1
+
+    def test_single_insertion(self):
+        assert typosquat.edit_distance("cat", "cart") == 1
+
+    def test_single_deletion(self):
+        assert typosquat.edit_distance("cart", "cat") == 1
+
+    def test_transposition_costs_two(self):
+        # Levenshtein (no adjacent-swap rule) scores a swap as two edits
+        assert typosquat.edit_distance("ab", "ba") == 2
+
+    def test_symmetric(self):
+        assert (typosquat.edit_distance("kitten", "sitting", cap=5)
+                == typosquat.edit_distance("sitting", "kitten", cap=5))
+
+    def test_classic_kitten_sitting_is_three(self):
+        assert typosquat.edit_distance("kitten", "sitting", cap=9) == 3
+
+    def test_empty_strings(self):
+        assert typosquat.edit_distance("", "") == 0
+        assert typosquat.edit_distance("", "abc", cap=5) == 3
+
+    def test_cap_returns_sentinel_when_farther(self):
+        # true distance is 3; with cap=1 we only learn "> cap" as cap + 1
+        assert typosquat.edit_distance("abcde", "xyzde", cap=1) == 2
+
+    def test_length_gap_shortcut(self):
+        # length difference alone exceeds the cap -> sentinel, no DP needed
+        assert typosquat.edit_distance("a", "aaaaaa", cap=2) == 3
+
+    def test_true_distance_returned_within_cap(self):
+        assert typosquat.edit_distance("foo", "foobar", cap=5) == 3
+
+
+class TestConfusableNames:
+    NAMES = ["brainstorm", "brainstorms", "brainstom", "commit", "unrelated"]
+
+    def test_finds_distance_one_only_by_default(self):
+        got = typosquat.confusable_names("brainstorm", self.NAMES)
+        assert got == ["brainstom", "brainstorms"]  # both 1 edit away
+
+    def test_exact_match_excluded(self):
+        assert "brainstorm" not in typosquat.confusable_names(
+            "brainstorm", self.NAMES)
+
+    def test_distance_two_needs_higher_max(self):
+        # "brainstrom" is 2 edits from "brainstorm" (swap) -> hidden at max 1
+        cands = ["brainstrom", "brainstorm"]
+        assert typosquat.confusable_names("brainstorm", cands) == []
+        assert typosquat.confusable_names(
+            "brainstorm", cands, max_distance=2) == ["brainstrom"]
+
+    def test_case_insensitive(self):
+        assert typosquat.confusable_names("Commit", ["commiy"]) == ["commiy"]
+
+    def test_deduplicates_case_variants(self):
+        assert typosquat.confusable_names("cat", ["cot", "COT"]) == ["cot"]
+
+    def test_sorted_by_distance_then_name(self):
+        # "care" is 2 from "cat"; "bat"/"cot" are 1 -> closest first, then a-z
+        got = typosquat.confusable_names("cat", ["cot", "bat", "care"],
+                                         max_distance=2)
+        assert got == ["bat", "cot", "care"]
+
+    def test_empty_candidates(self):
+        assert typosquat.confusable_names("cat", []) == []
+
+
+def _e(name, tap):
+    return {"name": name, "tap": tap}
+
+
+class TestFindConfusions:
+    def test_same_name_different_tap_flagged(self):
+        target = _e("deploy", "alice/skills")
+        entries = [target, _e("deploy", "mallory/evil")]
+        got = typosquat.find_confusions(target, entries)
+        assert [x["tap"] for x in got] == ["mallory/evil"]
+
+    def test_near_name_different_tap_flagged(self):
+        target = _e("deploy", "alice/skills")
+        got = typosquat.find_confusions(
+            target, [target, _e("deployy", "mallory/evil")])
+        assert [x["name"] for x in got] == ["deployy"]
+
+    def test_same_tap_never_flagged(self):
+        target = _e("deploy", "alice/skills")
+        # a sibling one edit away in the SAME tap is not a confusion
+        got = typosquat.find_confusions(
+            target, [target, _e("deployy", "alice/skills")])
+        assert got == []
+
+    def test_target_identity_excluded(self):
+        target = _e("deploy", "alice/skills")
+        assert typosquat.find_confusions(target, [target]) == []
+
+    def test_far_name_not_flagged(self):
+        target = _e("deploy", "alice/skills")
+        got = typosquat.find_confusions(
+            target, [target, _e("something-else", "mallory/evil")])
+        assert got == []
+
+    def test_respects_max_distance(self):
+        target = _e("deploy", "alice/skills")
+        entries = [target, _e("deproy", "x/y")]  # 1 edit
+        assert len(typosquat.find_confusions(target, entries)) == 1
+        assert typosquat.find_confusions(
+            target, [target, _e("depployy", "x/y")]) == []  # 2 edits, max 1
+
+    def test_sorted_by_distance_then_name_then_tap(self):
+        target = _e("deploy", "alice/skills")
+        entries = [
+            target,
+            _e("deployy", "z/last"),     # dist 1
+            _e("deploy", "a/first"),     # dist 0 -> should come first
+            _e("deploy", "m/mid"),       # dist 0
+        ]
+        got = typosquat.find_confusions(target, entries)
+        assert [(x["name"], x["tap"]) for x in got] == [
+            ("deploy", "a/first"), ("deploy", "m/mid"), ("deployy", "z/last")]