slopbrick 0.25.1 → 0.26.0

package/dist/engine/worker.js

@@ -36997,6 +36997,48 @@ var javaArraylistVsLinkedlistRule = createRule({
   }
 });
 
+// src/rules/java/builder-overuse.ts
+var BUILDER_ANNOTATION_REGEX = /@Builder\b/;
+var FIELD_DECL_REGEX = /(?:private|public|protected)\s+(?:final\s+)?[\w<>,\s]+\s+(\w+)\s*[=;]/g;
+var DEFAULT_FIELD_COUNT_CAP = 3;
+var javaBuilderOveruseRule = createRule({
+  id: "java/builder-overuse",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "@Builder on a class with few fields \u2014 plain constructor is simpler",
+  create(_context) {
+    return { fieldCountCap: DEFAULT_FIELD_COUNT_CAP };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\.java$/i.test(facts.filePath)) return issues;
+    BUILDER_ANNOTATION_REGEX.lastIndex = 0;
+    const builderMatch = BUILDER_ANNOTATION_REGEX.exec(source);
+    if (!builderMatch) return issues;
+    const firstBuilderLine = source.slice(0, builderMatch.index).split("\n").length;
+    FIELD_DECL_REGEX.lastIndex = 0;
+    let fieldCount = 0;
+    while (FIELD_DECL_REGEX.exec(source) !== null) {
+      fieldCount++;
+    }
+    if (fieldCount > context.fieldCountCap) return issues;
+    issues.push({
+      ruleId: "java/builder-overuse",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      message: `@Builder on a class with ${fieldCount} field(s) \u2014 plain constructor is simpler`,
+      line: firstBuilderLine,
+      column: 1,
+      advice: "Use a plain constructor for classes with \u2264 3 fields. AI agents default to @Builder because their training data emphasizes the pattern. Builder adds Lombok dependency and a Builder inner class for every annotated class. Reference: java/builder-overuse v0.26.0."
+    });
+    return issues;
+  }
+});
+
 // src/rules/java/empty-catch-block.ts
 var SINGLE_LINE_EMPTY_CATCH_REGEX = /catch\s*\([^)]*\)\s*\{\s*\}/g;
 var javaEmptyCatchBlockRule = createRule({
@@ -37032,6 +37074,58 @@ var javaEmptyCatchBlockRule = createRule({
   }
 });
 
+// src/rules/java/immutable-collection-preference.ts
+var IMMUTABLE_REGEX = /\b(List|Map|Set)\.of\s*\(/g;
+var MUTABLE_REGEX = /new\s+(ArrayList|HashMap|HashSet|LinkedList|TreeMap)\s*[<(]/g;
+var DEFAULT_IMMUTABLE_THRESHOLD = 5;
+var DEFAULT_MUTABLE_CAP = 1;
+var javaImmutableCollectionPreferenceRule = createRule({
+  id: "java/immutable-collection-preference",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Immutable factory method over-use \u2014 prefer mutable when collection will be modified",
+  create(_context) {
+    return {
+      immutableThreshold: DEFAULT_IMMUTABLE_THRESHOLD,
+      mutableCap: DEFAULT_MUTABLE_CAP
+    };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\.java$/i.test(facts.filePath)) return issues;
+    IMMUTABLE_REGEX.lastIndex = 0;
+    let immutableCount = 0;
+    let firstIdx = 0;
+    let m;
+    while ((m = IMMUTABLE_REGEX.exec(source)) !== null) {
+      immutableCount++;
+      if (firstIdx === 0) firstIdx = m.index;
+    }
+    if (immutableCount < context.immutableThreshold) return issues;
+    MUTABLE_REGEX.lastIndex = 0;
+    let mutableCount = 0;
+    while ((m = MUTABLE_REGEX.exec(source)) !== null) {
+      mutableCount++;
+    }
+    if (mutableCount > context.mutableCap) return issues;
+    const line = source.slice(0, firstIdx).split("\n").length;
+    issues.push({
+      ruleId: "java/immutable-collection-preference",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      message: `${immutableCount} immutable factory calls (List/Map/Set.of) with only ${mutableCount} mutable collection \u2014 likely over-preferring immutability`,
+      line,
+      column: 1,
+      advice: "Prefer mutable collections (new ArrayList<>()) when the collection will be modified later. AI agents default to List.of/Map.of/Set.of because their training data emphasizes functional-style Java. Reference: java/immutable-collection-preference v0.26.0."
+    });
+    return issues;
+  }
+});
+
 // src/rules/java/legacy-date-api.ts
 var LEGACY_IMPORT_REGEX = /^import\s+(?:static\s+)?java\.(?:util|sql)\.(?:Date|Calendar|GregorianCalendar)\s*;/gm;
 var LEGACY_USAGE_REGEX = /\bnew\s+(?:Date|GregorianCalendar)\s*\(/g;
@@ -37101,6 +37195,52 @@ var javaLegacyDateApiRule = createRule({
   }
 });
 
+// src/rules/java/optional-overuse.ts
+var OR_ELSE_THROW_REGEX = /\.orElseThrow\s*\(/g;
+var NULL_CHECK_REGEX = /Objects\.requireNonNull\s*\(|if\s*\([^)]*==\s*null\)\s*(?:throw|return)/g;
+var DEFAULT_THRESHOLD = 2;
+var javaOptionalOveruseRule = createRule({
+  id: "java/optional-overuse",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Optional chain over-use \u2014 null check or Objects.requireNonNull is faster",
+  create(_context) {
+    return { threshold: DEFAULT_THRESHOLD };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\.java$/i.test(facts.filePath)) return issues;
+    OR_ELSE_THROW_REGEX.lastIndex = 0;
+    let orElseThrowCount = 0;
+    let firstIdx = 0;
+    let m;
+    while ((m = OR_ELSE_THROW_REGEX.exec(source)) !== null) {
+      orElseThrowCount++;
+      if (firstIdx === 0) firstIdx = m.index;
+    }
+    if (orElseThrowCount < context.threshold) return issues;
+    NULL_CHECK_REGEX.lastIndex = 0;
+    const nullCheckCount = (source.match(NULL_CHECK_REGEX) ?? []).length;
+    const optionalRatio = orElseThrowCount / Math.max(orElseThrowCount + nullCheckCount, 1);
+    if (optionalRatio < 0.6) return issues;
+    const line = source.slice(0, firstIdx).split("\n").length;
+    issues.push({
+      ruleId: "java/optional-overuse",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      message: `${orElseThrowCount} .orElseThrow() calls with ${nullCheckCount} null checks \u2014 Optional chain over-use`,
+      line,
+      column: 1,
+      advice: 'Use Objects.requireNonNull(x, "msg") for null checks; reserve Optional for return values. AI agents default to Optional chains because their training data emphasizes null-safety. Real Java code uses null checks in hot paths. Reference: java/optional-overuse v0.26.0.'
+    });
+    return issues;
+  }
+});
+
 // src/rules/java/raw-type-overuse.ts
 var RAW_TYPE_REGEX = /\b(List|Map|Set|Collection|Iterable)\s+(?![<A-Z])(\w+)/g;
 var javaRawTypeOveruseRule = createRule({
@@ -37137,6 +37277,68 @@ var javaRawTypeOveruseRule = createRule({
   }
 });
 
+// src/rules/java/stream-overuse.ts
+var STREAM_OPS = [
+  ".map(",
+  ".filter(",
+  ".flatMap(",
+  ".collect(",
+  ".reduce(",
+  ".sorted(",
+  ".distinct(",
+  ".limit(",
+  ".skip(",
+  ".anyMatch(",
+  ".allMatch(",
+  ".noneMatch(",
+  ".findFirst(",
+  ".findAny("
+];
+var DEFAULT_CHAIN_THRESHOLD = 3;
+var javaStreamOveruseRule = createRule({
+  id: "java/stream-overuse",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Stream API chain over-use \u2014 for-loop is faster for simple transformations",
+  create(_context) {
+    return { chainThreshold: DEFAULT_CHAIN_THRESHOLD };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\.java$/i.test(facts.filePath)) return issues;
+    const lines = source.split("\n");
+    const streamOpPattern = new RegExp(STREAM_OPS.map((op) => op.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+    let firstOffendingLine = 0;
+    let firstOffendingCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      if (line.trim().startsWith("//") || line.trim().startsWith("*")) continue;
+      const matches = line.match(streamOpPattern);
+      if (matches && matches.length >= context.chainThreshold) {
+        if (firstOffendingLine === 0) {
+          firstOffendingLine = i + 1;
+          firstOffendingCount = matches.length;
+        }
+      }
+    }
+    if (firstOffendingLine === 0) return issues;
+    issues.push({
+      ruleId: "java/stream-overuse",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      message: `${firstOffendingCount} stream operations on a single line \u2014 for-loop is faster`,
+      line: firstOffendingLine,
+      column: 1,
+      advice: "Prefer a for-loop for simple transformations. AI agents default to Stream API chains because their training data emphasizes functional-style Java. Stream chains allocate intermediate objects; for small collections, a for-loop is faster and more readable. Reference: java/stream-overuse v0.26.0."
+    });
+    return issues;
+  }
+});
+
 // src/rules/java/string-concat-loop.ts
 var STRING_CONCAT_REGEX = /(\b\w+)\s*=\s*\1\s*\+\s*[^;]+;|(\b\w+)\s*\+=\s*['"`]/g;
 var javaStringConcatLoopRule = createRule({
@@ -37175,7 +37377,7 @@ var javaStringConcatLoopRule = createRule({
 
 // src/rules/java/system-out-println.ts
 var PRINTLN_REGEX = /System\.out\.println\s*\(/g;
-var DEFAULT_THRESHOLD = 1;
+var DEFAULT_THRESHOLD2 = 1;
 var javaSystemOutPrintlnRule = createRule({
   id: "java/system-out-println",
   category: "typo",
@@ -37183,7 +37385,7 @@ var javaSystemOutPrintlnRule = createRule({
   aiSpecific: true,
   description: "System.out.println in production code \u2014 use a logger (SLF4J, Log4j, etc.)",
   create(_context) {
-    return { threshold: DEFAULT_THRESHOLD };
+    return { threshold: DEFAULT_THRESHOLD2 };
   },
   analyze(context, facts) {
     const issues = [];
@@ -37216,6 +37418,56 @@ var javaSystemOutPrintlnRule = createRule({
   }
 });
 
+// src/rules/java/verbose-javadoc.ts
+var TAG_REGEX = /@(param|return|throws)\b/g;
+var DEFAULT_TAG_THRESHOLD = 3;
+var DEFAULT_BODY_LENGTH_CAP = 5;
+var javaVerboseJavadocRule = createRule({
+  id: "java/verbose-javadoc",
+  category: "typo",
+  severity: "low",
+  aiSpecific: true,
+  description: "Excessive Javadoc tags on trivial methods \u2014 over-documentation is an AI fingerprint",
+  create(_context) {
+    return {
+      tagThreshold: DEFAULT_TAG_THRESHOLD,
+      bodyLengthCap: DEFAULT_BODY_LENGTH_CAP
+    };
+  },
+  analyze(context, facts) {
+    const issues = [];
+    const source = facts.v2?._source;
+    if (!source) return issues;
+    if (!/\.java$/i.test(facts.filePath)) return issues;
+    TAG_REGEX.lastIndex = 0;
+    let tagCount = 0;
+    let firstTagLine = 0;
+    let m;
+    while ((m = TAG_REGEX.exec(source)) !== null) {
+      tagCount++;
+      if (firstTagLine === 0) {
+        firstTagLine = source.slice(0, m.index).split("\n").length;
+      }
+    }
+    if (tagCount < context.tagThreshold) return issues;
+    const lineCount = source.split("\n").length;
+    const tagDensity = tagCount / Math.max(lineCount, 1);
+    if (tagDensity < 0.05) return issues;
+    if (lineCount > 200) return issues;
+    issues.push({
+      ruleId: "java/verbose-javadoc",
+      category: "typo",
+      severity: "low",
+      aiSpecific: true,
+      message: `${tagCount} Javadoc tags in ${lineCount} lines (density ${(tagDensity * 100).toFixed(1)}%) \u2014 likely over-documented`,
+      line: firstTagLine,
+      column: 1,
+      advice: "Skip Javadoc on trivial methods (getters, setters, builders). AI agents default to over-documentation because their training data has countless textbook Javadoc examples. Real Java code limits Javadoc to public API surface. Reference: java/verbose-javadoc v0.26.0."
+    });
+    return issues;
+  }
+});
+
 // src/rules/kotlin/coroutine-global-scope.ts
 var GLOBAL_SCOPE_REGEX = /GlobalScope\s*\.\s*(?:launch|async|runBlocking)\s*[({]/g;
 var kotlinCoroutineGlobalScopeRule = createRule({
@@ -37360,7 +37612,7 @@ var kotlinObjectSingletonMisuseRule = createRule({
 
 // src/rules/kotlin/println-debug.ts
 var PRINTLN_REGEX2 = /^\s*println\s*\(/gm;
-var DEFAULT_THRESHOLD2 = 1;
+var DEFAULT_THRESHOLD3 = 1;
 var kotlinPrintlnDebugRule = createRule({
   id: "kotlin/println-debug",
   category: "typo",
@@ -37368,7 +37620,7 @@ var kotlinPrintlnDebugRule = createRule({
   aiSpecific: true,
   description: "println(...) in production code \u2014 use Timber, android.util.Log, or an SLF4J facade",
   create(_context) {
-    return { threshold: DEFAULT_THRESHOLD2 };
+    return { threshold: DEFAULT_THRESHOLD3 };
   },
   analyze(context, facts) {
     const issues = [];
@@ -40298,7 +40550,7 @@ var swiftImplicitlyUnwrappedOptionalRule = createRule({
 
 // src/rules/swift/print-debug.ts
 var PRINT_REGEX = /\bprint\s*\(/g;
-var DEFAULT_THRESHOLD3 = 1;
+var DEFAULT_THRESHOLD4 = 1;
 var swiftPrintDebugRule = createRule({
   id: "swift/print-debug",
   category: "typo",
@@ -40306,7 +40558,7 @@ var swiftPrintDebugRule = createRule({
   aiSpecific: true,
   description: "print(...) in production Swift \u2014 use Logger (os.log) for level-controlled output",
   create(_context) {
-    return { threshold: DEFAULT_THRESHOLD3 };
+    return { threshold: DEFAULT_THRESHOLD4 };
   },
   analyze(context, facts) {
     const issues = [];
@@ -42962,11 +43214,16 @@ var builtinRules = [
   goNilSliceVsEmptyRule,
   goStructTagInconsistencyRule,
   javaArraylistVsLinkedlistRule,
+  javaBuilderOveruseRule,
   javaEmptyCatchBlockRule,
+  javaImmutableCollectionPreferenceRule,
   javaLegacyDateApiRule,
+  javaOptionalOveruseRule,
   javaRawTypeOveruseRule,
+  javaStreamOveruseRule,
   javaStringConcatLoopRule,
   javaSystemOutPrintlnRule,
+  javaVerboseJavadocRule,
   kotlinCoroutineGlobalScopeRule,
   kotlinDataClassDefaultsOveruseRule,
   kotlinObjectSingletonMisuseRule,
@@ -43900,6 +44157,86 @@ var signal_strength_default = {
     _v9Precision: 0.0657,
     defaultOff: true
   },
+  "java/verbose-javadoc": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-03T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a small Java file (< 200 lines) has 3+ Javadoc tags with density >= 0.05. Calibration pending v9 Java corpus re-run; placeholder values until then. v0.20.0: anti-pattern design was wrong (humans write more Javadoc on trivial methods because their training data has it). v0.26.0: redesigned as positive signal (AI over-documents trivial methods). Reference: java/verbose-javadoc v0.26.0.",
+    aiSpecific: true,
+    _v9Verdict: "DORMANT",
+    _v9Lift: 1,
+    _v9Recall: 0,
+    _v9FpRate: 0,
+    _v9Precision: 0,
+    defaultOff: true
+  },
+  "java/optional-overuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-03T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a Java file has 2+ .orElseThrow() calls AND 0 Objects.requireNonNull()/null checks (optionalRatio > 0.6). Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI chains Optional.ofNullable().orElseThrow() where null checks would be cleaner). Reference: java/optional-overuse v0.26.0.",
+    aiSpecific: true,
+    _v9Verdict: "DORMANT",
+    _v9Lift: 1,
+    _v9Recall: 0,
+    _v9FpRate: 0,
+    _v9Precision: 0,
+    defaultOff: true
+  },
+  "java/immutable-collection-preference": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-03T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a Java file has 5+ List.of/Map.of/Set.of calls AND < 1 new ArrayList/HashMap/HashSet/LinkedList/TreeMap calls. Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI defaults to immutable factory methods). Reference: java/immutable-collection-preference v0.26.0.",
+    aiSpecific: true,
+    _v9Verdict: "DORMANT",
+    _v9Lift: 1,
+    _v9Recall: 0,
+    _v9FpRate: 0,
+    _v9Precision: 0,
+    defaultOff: true
+  },
+  "java/builder-overuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-03T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when @Builder annotation (Lombok) is used on a class with <= 3 fields. Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI defaults to Builder pattern even for simple data classes). Reference: java/builder-overuse v0.26.0.",
+    aiSpecific: true,
+    _v9Verdict: "DORMANT",
+    _v9Lift: 1,
+    _v9Recall: 0,
+    _v9FpRate: 0,
+    _v9Precision: 0,
+    defaultOff: true
+  },
+  "java/stream-overuse": {
+    recall: 0,
+    fpRate: 0,
+    ratio: 1,
+    precision: 0,
+    lastCalibratedAt: "2026-07-03T00:00:00Z",
+    verdict: "DORMANT",
+    _calibrationNote: "v0.26.0: new positive AI-signal rule. Triggers when a single line has 3+ Stream API operations (.map, .filter, .flatMap, .collect, .reduce, .sorted, .distinct, .limit, .skip, .anyMatch, .allMatch, .noneMatch, .findFirst, .findAny). Calibration pending v9 Java corpus re-run; placeholder values until then. v0.26.0: redesigned as positive signal (AI chains Stream API for everything). Reference: java/stream-overuse v0.26.0.",
+    aiSpecific: true,
+    _v9Verdict: "DORMANT",
+    _v9Lift: 1,
+    _v9Recall: 0,
+    _v9FpRate: 0,
+    _v9Precision: 0,
+    defaultOff: true
+  },
   "java/raw-type-overuse": {
     recall: 0.1093,
     fpRate: 0.2041,