boost-skill-cli 1.2.113__tar.gz → 1.2.114__tar.gz

{boost_skill_cli-1.2.113/boost_skill_cli.egg-info → boost_skill_cli-1.2.114}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.113
+Version: 1.2.114
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114}/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.113'
-__version_tuple__ = version_tuple = (1, 2, 113)
+__version__ = version = '1.2.114'
+__version_tuple__ = version_tuple = (1, 2, 114)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114}/boost_cli/core/bmad.py

@@ -389,7 +389,54 @@ under-route than talk over someone.
 """
 
 
-def classify(prompt: str) -> str:
+_NOT_INTENT = re.compile(
+    r"```.*?```"                           # fenced code
+    r"|`[^`\n]*`"                          # inline code
+    r"|\b(?:https?|ftp)://\S+|\bwww\.\S+"  # URLs
+    r"|(?<!\S)--?[a-z]\S*"                 # --flag, -f, --flag=value
+    r"|\b(?:story|ticket|issue|epic|task|bug|card|pr)\s+"
+    r"(?:[a-z][a-z0-9]*-\d+|#\d+)\b",      # story ABC-123, issue #42
+    re.IGNORECASE | re.DOTALL)
+"""Text that names something rather than asking for anything.
+
+A prompt of up to :data:`LONG_PROMPT_WORDS` routes on one keyword, so one match
+anywhere decided the track — including words nobody meant as intent. "rerun the
+installer with --scope global" went to product on `\\bscope\\b`, a link to
+`https://example.com/docs/...` went to docs, "move story ABC-123 to in progress"
+went to product. These spans are removed before any table is scored.
+"""
+
+_PATH_TOKEN = re.compile(r"\S*/\S*")
+"""A token with a `/` in it: a path, which `build` does not score.
+
+"tail logs/build/server.log" is not a build. The rule is build-only because a
+path is often the object of the ask — "update docs/README.md" must stay docs —
+and build is the catch-all whose single hits are the cheapest.
+"""
+
+_ADDRESSEE = re.compile(r"\b\w+\s+(?:me|us)\b", re.IGNORECASE)
+"""A verb aimed at the user, not the code: "update me when the CI run finishes".
+
+Build-only for the same reason as :data:`_PATH_TOKEN` — every build keyword is
+a verb that also reads as a request to *tell* someone something.
+"""
+
+
+def _intent_text(text: str, root: Path | str | None) -> str:
+    """`text` with everything that is not intent blanked out, for scoring.
+
+    The repo's own directory name goes too, whole-word: in a checkout called
+    `migrations`, "list the last three commits in migrations" is a `git log`,
+    not a migration. The hook already knows the root; this is where it counts.
+    """
+    text = _NOT_INTENT.sub(" ", text)
+    if root is not None and Path(root).name:
+        text = re.sub(r"(?<!\w)%s(?!\w)" % re.escape(Path(root).name), " ",
+                      text, flags=re.IGNORECASE)
+    return text
+
+
+def classify(prompt: str, root: Path | str | None = None) -> str:
     """Name the track a prompt belongs to, or ``"trivial"`` to stay silent.
 
     Silence is the default for anything that is not recognisably a unit of
@@ -397,6 +444,11 @@ def classify(prompt: str) -> str:
     own instructions), a short informational question, an explicit opt-out
     ("no bmad"), a prompt that matches no track at all, or — past
     :data:`LONG_PROMPT_WORDS` — one that matches only a single keyword.
+
+    Only intent is scored (:func:`_intent_text`): code spans, URLs, flags,
+    tracker IDs and the name of ``root`` — the repo the prompt was typed in —
+    never count, and ``build`` additionally ignores paths and verbs addressed
+    to the user. The threshold stays where it is; the evidence got cleaner.
     """
     text = prompt.strip()
     if not text or _SLASH.match(text) or _OPT_OUT.search(text):
@@ -407,9 +459,12 @@ def classify(prompt: str) -> str:
     if (_INFO_QUESTION.match(text) and len(words) <= QUESTION_MAX_WORDS
             and not _SECOND_SENTENCE.search(text)):
         return TRIVIAL
+    intent = _intent_text(text, root)
+    build_intent = _ADDRESSEE.sub(" ", _PATH_TOKEN.sub(" ", intent))
     # Distinct patterns matched, not occurrences: saying "update" twenty times
     # is one piece of evidence, which is what keeps a repetitive log quiet.
-    scores = {t: sum(1 for rx in pats if rx.search(text))
+    scores = {t: sum(1 for rx in pats
+                     if rx.search(build_intent if t == "build" else intent))
               for t, pats in _COMPILED.items()}
     best = max(scores.values())
     if best == 0 or (best < 2 and len(words) > LONG_PROMPT_WORDS):
@@ -526,12 +581,13 @@ def route_lines(prompt: str, root: Path | None = None) -> list[str]:
     Kept to a handful of lines on purpose — this is prepended to *every*
     substantive prompt, so its cost is paid on each turn of every session.
     """
-    track_name = classify(prompt)
+    root = Path(root) if root is not None else Path.cwd()
+    track_name = classify(prompt, root)
     if track_name == TRIVIAL:
         return []
     track = TRACKS[track_name]
     lead = PERSONA_BY_SLUG[track.lead]
-    signals = project_signals(Path(root) if root is not None else Path.cwd())
+    signals = project_signals(root)
 
     lines = [
         "[BMAD autopilot] track: %s" % track_name,

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.113
+Version: 1.2.114
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114}/docs/bmad.md

@@ -75,7 +75,11 @@ instead of being remembered afterwards.
 
 The router costs a question nothing. Acknowledgements, slash commands, short
 informational questions ("what does `scan_dir` do?") and anything containing
-`no bmad` produce no banner at all. Because a `UserPromptSubmit` hook that exits
+`no bmad` produce no banner at all. A short prompt routes on a single keyword, so
+only intent is scored: code spans, URLs, `--flags`, tracker IDs such as
+`story ABC-123` and the name of the repo you are in never count, and the `build`
+track also ignores paths and verbs aimed at you ("update me when CI finishes").
+Because a `UserPromptSubmit` hook that exits
 non-zero would erase your prompt, it degrades every failure to silence and
 always exits 0.
 

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114}/docs/roadmap/items/bmad-router-one-keyword-decides-the-track.md

@@ -2,15 +2,15 @@
 id: bmad-router-one-keyword-decides-the-track
 board: code
 section: dx
-status: next
+status: shipped
 category: Agents · BMAD
 complexity: S
 impact: High
 wow: 3
 note: 89 of 143 routed prompts rode on a single keyword
 order: 319
-owner:
-pr:
+owner: loop/bmad-incidental-keywords
+pr: 861
 title: One incidental keyword decides the <code>boost bmad</code> track
 ---
 <code>classify</code> counts distinct keyword patterns per track over the raw prompt and routes on

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114}/docs/roadmap.html

@@ -7564,67 +7564,9 @@ its own pass rather than a bolt-on inside this PR. Left <code>inflight</code> ra
       </article>
 
       <article class="cap rcard" id="bmad-router-one-keyword-decides-the-track">
-        <div class="head"><span class="pill next">Next</span><span class="cat">Agents · BMAD</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Agents · BMAD</span></div>
         <h3>One incidental keyword decides the <code>boost bmad</code> track</h3>
-        <p><code>classify</code> counts distinct keyword patterns per track over the raw prompt and routes on
-the best score (<code>core/bmad.py:412</code>&ndash;<code>417</code>). Two hits are required only
-past <code>LONG_PROMPT_WORDS</code> (60, #630; <code>:415</code>), so any prompt of up to 60 words
-that clears the question and slash gates <b>routes on one match anywhere</b> &mdash; including
-words nobody meant as intent: a URL, a path, a flag, a ticket reference, the repo's own name.
-Replaying the origin/main classifier over one real prompt history (417 prompts, 348 unique, 6
-active days): <b>89 of 143 routed unique prompts were decided by exactly one keyword</b>. A single
-judge labelling 41 routed banners found the track or lead clearly wrong in <b>21 of 41</b>.
-
-<b>A wrong route costs more than silence.</b> The banner names a lead, asks for support subagents,
-sets a done-contract (tests, docs, and the gate when there is one) and says to work autonomously
-(<code>:536</code>&ndash;<code>553</code>). In a repo directory named <code>migrations</code>,
-&ldquo;list the last three commits in migrations&rdquo; gets a 643-char build banner &mdash; Amelia
-leads, Murat and Paige to be spawned, <code>make check</code> green &mdash; for a
-<code>git log</code>. The module already chose: it &ldquo;would rather under-route than talk over
-someone&rdquo; (<code>:387</code>&ndash;<code>388</code>).
-
-<b>Five collision classes, all single hits, reproduced on origin/main with synthetic prompts</b>
-(three spot-checked on the installed v1.2.112): <i>repo name</i> &mdash; &ldquo;list the last three
-commits in migrations&rdquo; in <code>migrations/</code> &rarr; build, &ldquo;list the new notebooks
-in benchmarks&rdquo; in <code>benchmarks/</code> &rarr; discovery; <i>flags</i> &mdash; &ldquo;rerun
-the installer with <code>--scope</code> global&hellip;&rdquo; &rarr; product; <i>URLs, paths,
-code</i> &mdash; <code>https://example.com/docs/&hellip;</code> &rarr; docs, <code>tail
-logs/build/server.log</code> &rarr; build, <code>`npm run build`</code> &rarr; build; <i>tracker
-words</i> &mdash; &ldquo;move story ABC-123 to in progress&rdquo; &rarr; product; <i>generic
-verbs</i> &mdash; &ldquo;update me when the CI run finishes&rdquo; &rarr; build. The hook already
-has the repo &mdash; <code>cwd</code> becomes <code>root</code>
-(<code>commands/bmad.py:342</code>&ndash;<code>344</code>) &mdash; but <code>route_lines</code>
-calls <code>classify(prompt)</code> bare (<code>core/bmad.py:529</code>).
-
-<b>Fix: stop scoring text that is not intent; do not raise the threshold.</b> Before scoring,
-<i>(1)</i> drop URLs, backtick spans, <code>--flag</code>/<code>-f</code> tokens and tracker-noun +
-ID pairs (<code>story ABC-123</code>); <i>(2)</i> a token containing <code>/</code> stops scoring
-for <code>build</code> but still counts for every other table, so <code>docs/README.md</code>
-stays docs; <i>(3)</i> <code>classify(prompt, root=None)</code>, fed by <code>route_lines</code>,
-drops whole-word matches of <code>Path(root).name</code>; <i>(4)</i> a build verb followed by
-<em>me</em>/<em>us</em> does not score. On a stdlib prototype: all <b>46</b> distinct prompts
-<code>test_bmad_core.py</code> sends through <code>classify</code> keep their verdict; <b>16 of
-18</b> synthetic misroutes go silent; build asks still route &mdash; 12/12 verb-first, 8/8 not
-(&ldquo;we need to fix the crash&hellip;&rdquo;), 4/4 late-verb &mdash; and 5/5 path-object asks
-keep their track. Small hand-written sets: they show which rule does the work, not a rate.
-
-<b>Threshold rules measured and declined.</b> Layered on <i>(1)</i>&ndash;<i>(4)</i>: two build hits
-or a head verb silences neither of the 2 left but routes <b>2 of 8</b> non-head and <b>0 of 4</b>
-late-verb asks; a verb in a clause's first six words routes <b>0 of 4</b> late-verb asks; making
-<code>add</code>/<code>update</code>/<code>create</code>-class verbs need a second hit silences one
-more but keeps only <b>6 of 12</b> short build asks and breaks <code>"update the flag"</code>
-(<code>test_bmad_core.py:142</code>). Stripping paths outright flips 3 of 5 path-object asks.
-<b>Residue:</b> &ldquo;add the meeting notes to my summary&rdquo; stays build; &ldquo;pull the
-comments on story ABC-123&hellip;&rdquo; goes docs on <code>\bcomments?\b</code>; a sibling repo's
-name still routes; and a cwd named after a keyword loses that word &mdash; in <code>tests/</code>,
-&ldquo;add tests for catalog.scan_dir&rdquo; flips quality &rarr; build.
-
-<b>Tests:</b> add <code>TestIncidentalKeywords</code> beside <code>TestClassifyTracks</code>
-(<code>tests/unit/test_bmad_core.py:173</code>): one <code>(prompt, repo_dirname, expected)</code>
-table with every repro as <code>trivial</code> except the two residues (pinned at today's track,
-so a later fix shows as a diff), the non-head, late-verb and path-object asks at their tracks,
-plus a <code>route_lines</code> case rooted at <code>tmp_path / "migrations"</code> so the name
-must reach <code>classify</code>.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-router-one-keyword-decides-the-track.md">Write-up &middot; bmad-router-one-keyword-decides-the-track.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m hi">Impact <b>High</b></span>

{boost_skill_cli-1.2.113 → boost_skill_cli-1.2.114}/tests/unit/test_bmad_core.py

@@ -155,6 +155,18 @@ boost bmad install
         assert len(prompt.split()) > bmad.LONG_PROMPT_WORDS
         assert bmad.classify(prompt) == "build"
 
+    def test_exactly_two_hits_is_enough_past_the_cutoff(self):
+        """The long-prompt rule asks for two hits, not three."""
+        prompt = "please refactor it and update it " + "blah " * bmad.LONG_PROMPT_WORDS
+        assert len(prompt.split()) > bmad.LONG_PROMPT_WORDS
+        assert bmad.classify(prompt) == "build"
+
+    def test_one_hit_at_exactly_the_cutoff_still_routes(self):
+        """The cutoff is exclusive: a 60-word prompt is still short enough."""
+        prompt = "please refactor it " + "blah " * (bmad.LONG_PROMPT_WORDS - 3)
+        assert len(prompt.split()) == bmad.LONG_PROMPT_WORDS
+        assert bmad.classify(prompt) == "build"
+
     def test_repeating_one_keyword_is_not_more_evidence(self):
         """Scoring counts distinct patterns, not occurrences — so a long log
         that says "update" twenty times still scores 1 and stays silent."""
@@ -228,6 +240,81 @@ class TestClassifyTracks:
         assert bmad.classify("ADD TESTS FOR THE SCANNER") == "quality"
 
 
+class TestIncidentalKeywords:
+    """A prompt of up to 60 words routes on one keyword, so it must be intent.
+
+    Replayed over a real prompt history, 89 of 143 routed prompts were decided
+    by exactly one keyword — often one nobody meant: a URL, a path, a flag, a
+    tracker ID, the repo's own name. Every row marked trivial below routed on
+    origin/main (the track it went to is in the comment). The fix removes text
+    that is not intent before scoring rather than raising the threshold, which
+    measured worse on genuine short asks.
+    """
+
+    @pytest.mark.parametrize("prompt,repo,expected", [
+        # the repo's own name (was: build, discovery, discovery)
+        ("list the last three commits in migrations", "migrations", "trivial"),
+        ("list the new notebooks in benchmarks", "benchmarks", "trivial"),
+        ("list the new notebooks in Benchmarks", "benchmarks", "trivial"),
+        # flags, long and short (was: product, quality)
+        ("rerun the installer with --scope global and paste the output",
+         "proj", "trivial"),
+        ("rerun mvn package with -Dmaven.test.skip=true and paste the log",
+         "proj", "trivial"),
+        # URLs (was: docs, docs)
+        ("open https://example.com/docs/setup and paste what it says",
+         "proj", "trivial"),
+        ("open www.example.com/docs and paste what it says", "proj", "trivial"),
+        # code, inline and fenced (was: build, build)
+        ("paste the output of `npm run build` here", "proj", "trivial"),
+        ("paste what this prints:\n```\nnpm run build\n```", "proj", "trivial"),
+        # a path, for build only (was: build)
+        ("tail logs/build/server.log and paste the last error", "proj", "trivial"),
+        # tracker IDs (was: product, build)
+        ("move story ABC-123 to in progress", "proj", "trivial"),
+        ("close bug #42 in the tracker", "proj", "trivial"),
+        # a verb aimed at the user (was: build, build)
+        ("update me when the CI run finishes", "proj", "trivial"),
+        ("keep an eye on it and update us once the deploy is done",
+         "proj", "trivial"),
+        # residue, pinned where it lands today so a later fix shows as a diff
+        ("add the meeting notes to my summary", "proj", "build"),
+        ("pull the comments on story ABC-123 into a list", "proj", "docs"),
+        ("add tests for catalog.scan_dir", "tests", "build"),
+        # a name is dropped whole-word only
+        ("add tests for catalog.scan_dir", "test", "quality"),
+        # genuine asks keep routing: not verb-first, late verb, path objects
+        ("we need to fix the crash in the exporter", "proj", "build"),
+        ("the scanner is slow, so refactor the walk loop", "proj", "build"),
+        ("once that lands, please implement the export command", "proj", "build"),
+        ("fix the crash in boost_cli/core/store.py", "proj", "build"),
+        ("fix bug ABC-123 in the exporter", "proj", "build"),
+        ("update docs/README.md with the new flag", "proj", "docs"),
+        ("add tests to tests/unit/test_catalog.py", "proj", "quality"),
+        ("document the helpers in boost_cli/core/rag.py", "proj", "docs"),
+    ])
+    def test_only_intent_is_scored(self, prompt, repo, expected):
+        assert bmad.classify(prompt, Path("/work") / repo) == expected
+
+    def test_a_removed_span_does_not_glue_its_neighbours(self):
+        """Blanked out, not deleted: `rename` must still read as a word."""
+        assert bmad.classify("rename`load_tap`to`read_tap` in the scanner") == "build"
+
+    def test_no_root_means_no_name_is_dropped(self):
+        assert bmad.classify("list the last three commits in migrations") == "build"
+
+    def test_a_root_with_no_name_drops_nothing(self):
+        assert bmad.classify("fix the bug", Path("/")) == "build"
+
+    def test_the_hook_root_reaches_the_classifier(self, tmp_path):
+        """`route_lines` has the repo; the name only counts if it passes it on."""
+        root = tmp_path / "migrations"
+        root.mkdir()
+        prompt = "list the last three commits in migrations"
+        assert bmad.route_lines(prompt, root) == []
+        assert bmad.route_lines(prompt, tmp_path) != []
+
+
 # ------------------------------------------------------------- project signals
 
 class TestProjectSignals: