@blumintinc/eslint-plugin-blumint 1.18.15 → 1.19.0

package/lib/rules/no-harness-coupled-disables.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noHarnessCoupledDisables = void 0;
+const createRule_1 = require("../utils/createRule");
+/**
+ * Recognizes ESLint disable directives (block or line) by their leading
+ * keyword. `eslint-enable` deliberately does not match: it carries no
+ * justification to classify.
+ */
+const DIRECTIVE_PREFIX = /^eslint-disable(?:-next-line|-line)?\b/;
+/**
+ * Unconditional harness terms — always flag. Each describes the Claude Code
+ * CLI development harness and has no code-level meaning in a suppression
+ * reason. When several co-occur, the one appearing FIRST in the justification
+ * text is reported (see `findHarnessTerm`), so "claude session ... cwd" reports
+ * `claude`, not `cwd`.
+ */
+const UNCONDITIONAL_MATCHERS = [
+    // Word-boundary start, suffix/compound tolerant: worktree, worktrees,
+    // worktree-cwd, cross-worktree, worktree-hook.
+    { term: 'worktree', pattern: /\bworktree/ },
+    // Word-boundary token, plural/possessive tolerant: cwd, cwds, cwd's.
+    { term: 'cwd', pattern: /\bcwd(?:'?s)?\b/ },
+    // Word-boundary start: claude, claude's, claude-code, claude code.
+    { term: 'claude', pattern: /\bclaude/ },
+    // The Claude Code Stop hook compound: stop-hook / stop hook / stop_hook,
+    // plus near-adjacent forms with at most one intervening word ("stop lint
+    // hook"). Distant incidental co-occurrence of "stop" and "hook" does not
+    // match, keeping bare React-hook justifications safe.
+    { term: 'stop-hook', pattern: /\bstop[-_ ]+(?:\w+[-_ ]+)?hook/ },
+];
+/**
+ * Conditional session compound. `session` (auth session) is legitimate
+ * code-level vocabulary, so it only flags in the unambiguous harness compounds
+ * `agent session` / `claude session`. When it co-occurs with an unconditional
+ * term, that term reports instead — so in practice only `agent session`
+ * surfaces `session` as the matched term.
+ */
+const SESSION_MATCHER = {
+    term: 'session',
+    pattern: /\b(?:agent|claude)[-_ ]+sessions?\b/,
+};
+function isDirectiveComment(comment) {
+    return DIRECTIVE_PREFIX.test(comment.value.trim());
+}
+/**
+ * Isolates the justification text of a directive comment: everything after the
+ * first `--` separator, spanning every line of a multi-line block body. The
+ * directive keyword and the comma-separated rule-name list both precede the
+ * `--` (and never contain `--`), so slicing past it strips them in one step.
+ * Returns `null` when there is no `--` — a bare disable with no justification
+ * is out of scope.
+ */
+function extractJustification(comment) {
+    const separatorIndex = comment.value.indexOf('--');
+    if (separatorIndex === -1) {
+        return null;
+    }
+    return comment.value.slice(separatorIndex + 2);
+}
+function findHarnessTerm(text) {
+    const lowered = text.toLowerCase();
+    let earliest = null;
+    for (const { term, pattern } of UNCONDITIONAL_MATCHERS) {
+        const match = pattern.exec(lowered);
+        if (match && (earliest === null || match.index < earliest.index)) {
+            earliest = { term, index: match.index };
+        }
+    }
+    if (earliest !== null) {
+        return earliest.term;
+    }
+    // Only reached when no unconditional term is present: an isolated harness
+    // session compound.
+    if (SESSION_MATCHER.pattern.test(lowered)) {
+        return SESSION_MATCHER.term;
+    }
+    return null;
+}
+exports.noHarnessCoupledDisables = (0, createRule_1.createRule)({
+    name: 'no-harness-coupled-disables',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow eslint-disable justifications that reference the agent development harness (worktree, cwd, stop-hook, claude) instead of the code’s own semantics.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            harnessCoupled: "This eslint-disable justification references the development harness ('{{matchedTerm}}'), not the code's own semantics. Harness quirks (how the stop hook invokes lint, cwd resolution, worktree path mapping) belong in harness config — fix the hook, not the source. See the harness docs referenced in the disable-directive hygiene section of the repo's linting skill doc. If this disable is NOT harness-related and the word is a false match (e.g. 'hook' meaning a React hook), rephrase the justification to describe the code-level reason instead.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const comments = sourceCode.getAllComments();
+        return {
+            Program() {
+                comments.forEach((comment, index) => {
+                    if (!isDirectiveComment(comment)) {
+                        return;
+                    }
+                    const justification = extractJustification(comment);
+                    // No `--` separator, or nothing but whitespace after it: a bare
+                    // disable carries no justification to classify (out of scope).
+                    if (justification === null || justification.trim() === '') {
+                        return;
+                    }
+                    // Split-justification style: an immediately-adjacent preceding
+                    // non-directive comment (no intervening blank line or code) is part
+                    // of the directive's rationale when the directive defers to it.
+                    let scanned = justification;
+                    const previous = comments[index - 1];
+                    if (previous &&
+                        !isDirectiveComment(previous) &&
+                        comment.loc.start.line - previous.loc.end.line <= 1) {
+                        scanned = `${previous.value}\n${scanned}`;
+                    }
+                    const matchedTerm = findHarnessTerm(scanned);
+                    if (matchedTerm === null) {
+                        return;
+                    }
+                    context.report({
+                        loc: comment.loc,
+                        messageId: 'harnessCoupled',
+                        data: { matchedTerm },
+                    });
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-harness-coupled-disables.js.map

package/lib/rules/no-hungarian.js

@@ -298,6 +298,15 @@ function isDomainNumberCompound(name) {
     const lastSegment = segments[segments.length - 1];
     return (!!lastSegment && DOMAIN_NUMBER_HEAD_NOUNS.has(lastSegment.toLowerCase()));
 }
+// Rebuild a SCREAMING_SNAKE_CASE identifier's segments into a PascalCase compound
+// (["MATCH","NUMBER"] -> "MatchNumber") so the snake-case branch can reuse the
+// camelCase isDomainNumberCompound / DOMAIN_NUMBER_HEAD_NOUNS exemption verbatim,
+// keeping MATCH_NUMBER and matchNumber on a single code path (#1294).
+function screamingSnakePartsToPascalCase(parts) {
+    return parts
+        .map((part) => part.charAt(0) + part.slice(1).toLowerCase())
+        .join('');
+}
 exports.noHungarian = (0, createRule_1.createRule)({
     name: 'no-hungarian',
     meta: {
@@ -387,12 +396,31 @@ exports.noHungarian = (0, createRule_1.createRule)({
                         if (isAbbreviation) {
                             return true;
                         }
-                        // A FULL type word tags the entity's type only at the start (prefix),
-                        // the end (suffix), or directly before the final noun
-                        // (..._STRING_NAME). Buried deeper (EDITABLE_WRAPPER_NUMBER_PROPS_…)
-                        // it qualifies an intermediate segment — a descriptive variant, not a
-                        // type tag.
-                        return (index === 0 || index === lastIndex || index === lastIndex - 1);
+                        // A FULL type word tags the entity's runtime type only as a genuine
+                        // leading prefix (index 0) or trailing head-noun (last segment).
+                        // Mirror the camelCase/PascalCase branch, which never flags a
+                        // full-type-word in a MIDDLE segment: an interior NUMBER/STRING is a
+                        // domain modifier describing a variant (CADENCE_NUMBER_EDITORS —
+                        // "editors of a numeric cadence"), not a redundant type tag. The
+                        // previous `index === lastIndex - 1` allowance produced a casing
+                        // asymmetry — CadenceNumberEditor was exempt (#1250) but
+                        // CADENCE_NUMBER_EDITORS fired (#1294).
+                        if (index !== 0 && index !== lastIndex) {
+                            return false;
+                        }
+                        // A trailing "..._NUMBER" whose preceding head noun is a domain
+                        // entity (MATCH_NUMBER, ISSUE_NUMBER, CURRENT_LINE_NUMBER) is a
+                        // domain compound, not a Hungarian type tag — route through the same
+                        // isDomainNumberCompound carve-out used for camelCase matchNumber
+                        // (#1277), so numeric-quantity heads (COUNT_NUMBER, MAX_RETRY_NUMBER)
+                        // still fire because those heads are absent from
+                        // DOMAIN_NUMBER_HEAD_NOUNS.
+                        if (normalizedMarker === 'number' &&
+                            index === lastIndex &&
+                            isDomainNumberCompound(screamingSnakePartsToPascalCase(parts))) {
+                            return false;
+                        }
+                        return true;
                     });
                 });
             }

package/lib/rules/prefer-clone-deep.js

@@ -52,15 +52,20 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                         node.key.callee.name === 'Symbol')) {
                     hasSymbol = true;
                 }
-                // Visit child nodes without traversing parent references
+                // Visit child nodes without traversing parent references. Depth tracks
+                // object-nesting level: an object's OWN direct properties stay at the
+                // object's depth, and only descending into a property's value (a
+                // genuinely nested child) increments it. This keeps the top-level
+                // object's own `...spread` at depth 0 so it is never miscounted as a
+                // nested spread.
                 if (node.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                     if (depth > 0) {
                         hasNestedObject = true;
                     }
-                    node.properties.forEach((prop) => visit(prop, depth + 1));
+                    node.properties.forEach((prop) => visit(prop, depth));
                 }
                 else if (node.type === utils_1.AST_NODE_TYPES.Property) {
-                    visit(node.value, depth);
+                    visit(node.value, depth + 1);
                 }
                 else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
                     visit(node.argument, depth);

package/lib/rules/prefer-map-over-conditional-dispatch.d.ts

@@ -0,0 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferMap' | 'preferMapManual';
+export declare const preferMapOverConditionalDispatch: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
+export {};