slopbrick 0.25.1 → 0.26.1

package/dist/engine/worker.cjs

@@ -37026,6 +37026,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({
@@ -37061,6 +37103,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;
@@ -37130,6 +37224,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({
@@ -37166,6 +37306,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({
@@ -37204,7 +37406,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",
@@ -37212,7 +37414,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 = [];
@@ -37245,6 +37447,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({
@@ -37389,7 +37641,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",
@@ -37397,7 +37649,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 = [];
@@ -40327,7 +40579,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",
@@ -40335,7 +40587,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 = [];
@@ -42991,11 +43243,16 @@ var builtinRules = [
   goNilSliceVsEmptyRule,
   goStructTagInconsistencyRule,
   javaArraylistVsLinkedlistRule,
+  javaBuilderOveruseRule,
   javaEmptyCatchBlockRule,
+  javaImmutableCollectionPreferenceRule,
   javaLegacyDateApiRule,
+  javaOptionalOveruseRule,
   javaRawTypeOveruseRule,
+  javaStreamOveruseRule,
   javaStringConcatLoopRule,
   javaSystemOutPrintlnRule,
+  javaVerboseJavadocRule,
   kotlinCoroutineGlobalScopeRule,
   kotlinDataClassDefaultsOveruseRule,
   kotlinObjectSingletonMisuseRule,
@@ -43929,6 +44186,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. v0.26.1 CALIBRATION (14769-file biased sample from v9-java corpus, files that fired >=1 of the 6 existing java rules): TP=0, FP=0, ratio=N/A. HYPOTHESIS FAILED. The v0.26.0 intuition that 'AI over-documents trivial methods' is NOT supported by the v9 corpus \u2014 AI code in Spring AI, LangChain4j, etc. has the same Javadoc density as human code. v0.20 hypothesis (humans avoid println/Date/raw types) and v0.26 hypothesis (AI over-documents/over-Opts/over-Builders) are both wrong for the v9 corpus. v0.27+ will redesign with a different approach: either train a classifier on the v9 features or use AST-based detection rather than regex heuristics. Reference: java/verbose-javadoc v0.26.0; calibration v0.26.1.",
+    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). v0.26.1 CALIBRATION (14769-file biased sample): TP=0, FP=0, ratio=N/A. HYPOTHESIS FAILED. AI in the v9 corpus does NOT use Optional chains more than humans. v0.27+ will redesign. Reference: java/optional-overuse v0.26.0; calibration v0.26.1.",
+    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. v0.26.1 CALIBRATION (14769-file biased sample): TP=0, FP=0, ratio=N/A. HYPOTHESIS FAILED. AI does NOT use immutable factory methods more than humans. v0.27+ will redesign. Reference: java/immutable-collection-preference v0.26.0; calibration v0.26.1.",
+    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. v0.26.1 CALIBRATION (14769-file biased sample): TP=0, FP=0, ratio=N/A. HYPOTHESIS FAILED. AI does NOT use @Builder on small classes more than humans. v0.27+ will redesign. Reference: java/builder-overuse v0.26.0; calibration v0.26.1.",
+    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). v0.26.1 CALIBRATION (14769-file biased sample): TP=0, FP=0, ratio=N/A. HYPOTHESIS FAILED. AI does NOT use Stream API chains more than humans. v0.27+ will redesign. Reference: java/stream-overuse v0.26.0; calibration v0.26.1.",
+    aiSpecific: true,
+    _v9Verdict: "DORMANT",
+    _v9Lift: 1,
+    _v9Recall: 0,
+    _v9FpRate: 0,
+    _v9Precision: 0,
+    defaultOff: true
+  },
   "java/raw-type-overuse": {
     recall: 0.1093,
     fpRate: 0.2041,