super-ux 0.59.1 → 0.59.2

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.59.2 — brand-lint names the line, and a release refuses a lightweight tag
+
+- **`B022` reports the line.** An unregistered literal was reported at line 0 —
+  `B022 bin/super-ux.js:0` for a string on line 303 — so the finding named a file
+  and left the search to the reader. Code literals now carry the line their first
+  character is on (template-literal paragraphs included), HTML controls the line
+  they open on. The comment scanner keeps a block comment's newlines so a stripped
+  comment cannot shift the count. Fixture `b022_line_cases` in
+  `test/brand_lint_test.py`; three plants (line 0 back, comment newlines dropped,
+  HTML line pinned) each turned it red.
+- **The probe string that fired it is retired, not registered.** `claude --version`
+  in `bin/super-ux.js` was the `command` field of the typed result returned when the
+  claude CLI is absent; nothing prints it. B022's doctrine is "agree it or retire
+  it", and a row in `strings.md` would register as interface copy a string no
+  reader sees, so the field is now derived from the probe's own argv, the way
+  `run()` derives every other `command`. `python3 docs/brand/lint.py` is clean.
+- **The release refuses a lightweight tag.** A step right after checkout in
+  `release.yml` fails unless `git cat-file -t <tag>` is `tag`. `git describe` and
+  `git submodule status` see annotated tags only; v0.59.1 was cut lightweight and
+  the hub read super-ux as its previous release.
+
 ## 0.59.1 — inventories and audits work without delegation
 
 Brand inventory, scenario inventory and UX audit now use the same areas, batches

package/bin/super-ux.js

@@ -294,13 +294,17 @@ function printUpdateLine() {
 
 function installClaudePlugin() {
   console.log(`\n--- Claude Code plugin ---`);
-  const probe = spawnSync('claude', ['--version'], { stdio: 'ignore' });
+  // The probe's argv is the one source of its `command`, exactly as run()
+  // derives it: the typed result carries it, nothing prints it, so it is not
+  // interface copy and gets no strings.md row (brand-lint B022, retired).
+  const probeArgv = ['claude', '--version'];
+  const probe = spawnSync(probeArgv[0], probeArgv.slice(1), { stdio: 'ignore' });
   if (probe.error && probe.error.code === 'ENOENT') {
     console.log(`claude CLI not found. Run inside Claude Code instead:
   /plugin marketplace add ${REPO}
   /plugin install super-ux@super-ux`);
     return { status: 'unsupported', code: null, signal: null,
-             command: 'claude --version' };
+             command: probeArgv.join(' ') };
   }
   if (run('claude', ['plugin', 'marketplace', 'add', REPO]).status !== 'ok') {
     console.log('(marketplace may already be added, continuing)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-ux",
-  "version": "0.59.1",
+  "version": "0.59.2",
   "scripts": {
     "test": "python3 test/validate.py && python3 test/brand_lint_test.py && python3 test/display_copy_test.py && python3 test/ux_lint_test.py && python3 docs/ux/lint.py && python3 docs/brand/lint.py && node test/installer_test.js && npm run test:audit",
     "test:audit": "for t in test/audit_regressions/*.py; do python3 \"$t\" || exit 1; done"

package/plugins/super-ux/scripts/brand_lint.py

@@ -560,16 +560,38 @@ def code_literals(text: str) -> list[str]:
     Comments must already be stripped by the caller -- `_strip_comments` leaves
     literals untouched, which is what makes both patterns below safe to run.
     """
-    out: list[str] = [lit for _quote, lit in LITERAL_RE.findall(text)]
-    for block in TEMPLATE_RE.findall(text):
+    return [lit for lit, _line in code_literals_at(text)]
+
+
+def code_literals_at(text: str) -> list[tuple[str, int]]:
+    """`code_literals`, each with the 1-based line its first character is on.
+
+    B022 reported every unregistered literal at line 0 -- `bin/super-ux.js:0`
+    for a string on line 303 -- so the finding named a file and left the reader
+    to search it. The line is counted in the comment-stripped text, which
+    `_strip_comments` keeps line-for-line with the source (a block comment
+    leaves its newlines behind), so the number is the source's own.
+    """
+    def line_at(offset: int) -> int:
+        return text.count("\n", 0, offset) + 1
+
+    out: list[tuple[str, int]] = [
+        (m.group(2), line_at(m.start(2))) for m in LITERAL_RE.finditer(text)
+    ]
+    for m in TEMPLATE_RE.finditer(text):
+        block = m.group(1)
         if "\n" not in block:
             continue          # single-line backticks are already in `out`
+        cursor = 0
         for para in re.split(r"\n\s*\n", block):
+            at = block.find(para, cursor)
+            cursor = at + len(para)
             joined = " ".join(
                 line.strip() for line in para.splitlines() if line.strip()
             )
             if len(joined) >= 3:
-                out.append(joined)
+                lead = len(para) - len(para.lstrip())
+                out.append((joined, line_at(m.start(1) + at + lead)))
     return out
 
 # A template literal's interpolations split it into pieces, and the pieces are
@@ -742,10 +764,13 @@ def check_consistency(brand_dir: Path, sources: dict) -> list[Finding]:
         body = read(target) or ""
         html = html_copy(body) if target.suffix.lower() in HTML_SUFFIXES else None
         source_copy = " ".join(html.blocks) if html is not None else body
-        literals = html.interface_texts if html is not None else [
-            lit for lit in code_literals(_strip_comments(body, target.suffix))
-            if _looks_like_copy(lit)
-        ]
+        located = list(zip(html.interface_texts, html.interface_lines)) \
+            if html is not None else [
+                (lit, line) for lit, line
+                in code_literals_at(_strip_comments(body, target.suffix))
+                if _looks_like_copy(lit)
+            ]
+        literals = [lit for lit, _line in located]
         if literals or html is not None:
             # The registry records what a reader sees, so the built page is the
             # authority whenever there is one. Source is the fallback and stays
@@ -781,10 +806,13 @@ def check_consistency(brand_dir: Path, sources: dict) -> list[Finding]:
                 swept.add(file_part)
                 known = {r["text"] for r in rows}
                 trimmed = {t.strip() for t in known}
-                for lit in dict.fromkeys(literals):   # one report per literal
+                first_line: dict[str, int] = {}
+                for lit, line in located:     # one report per literal, at its first line
+                    first_line.setdefault(lit, line)
+                for lit, line in first_line.items():
                     if lit not in known and lit.strip() not in trimmed:
                         findings.append(Finding(
-                            "B022", SEVERITY_WARN, f"{file_part}", 0,
+                            "B022", SEVERITY_WARN, f"{file_part}", line,
                             f"\"{lit}\" is in the code with no registry row -- "
                             f"agree it or retire it",
                         ))
@@ -927,6 +955,7 @@ class HTMLCopy(HTMLParser):
         self.last_anchor_end = None
         self.controls = []
         self.interface_texts = []
+        self.interface_lines = []   # parallel to interface_texts: the control's opening line
 
     @property
     def blocked(self):
@@ -939,7 +968,7 @@ class HTMLCopy(HTMLParser):
                       attrs.get("style", ""), re.I))
         if not hidden:
             if tag in self.CONTROLS or attrs.get("role", "").lower() in self.INTERFACE_ROLES:
-                self.controls.append((tag, len(self.stack), []))
+                self.controls.append((tag, len(self.stack), [], self.getpos()[0]))
             if tag == "br" or tag in self.BLOCK or re.fullmatch(r"h[1-6]", tag):
                 for control in self.controls:
                     control[2].append(" ")
@@ -978,6 +1007,7 @@ class HTMLCopy(HTMLParser):
                 text = " ".join("".join(control[2]).split())
                 if text:
                     self.interface_texts.append(text)
+                    self.interface_lines.append(control[3])
                 self.controls.remove(control)
         if tag == "a" and not self.blocked:
             self.last_anchor_end = len(self.parts)
@@ -1106,7 +1136,12 @@ def _strip_comments(text: str, suffix: str) -> str:
             continue
         if not hashed and text.startswith("/*", i):
             end = text.find("*/", i + 2)
-            i = n if end == -1 else end + 2
+            stop = n if end == -1 else end + 2
+            # Keep the comment's newlines: B022 reports a literal by its line
+            # in THIS text, so a stripped multi-line comment must not shift
+            # every line after it.
+            out.append("\n" * text.count("\n", i, stop))
+            i = stop
             continue
         out.append(ch)
         i += 1