@qball-inc/the-bulwark 1.0.0

package/skills/bug-magnet-data/data/language-specific/rust.yaml

@@ -0,0 +1,148 @@
+metadata:
+  version: "1.0.0"
+  last_updated: "2026-02-01"
+  source_urls: []
+
+category: language-specific
+subcategory: rust
+tier: T2
+
+bugs_caught:
+  - "Ownership and borrowing edge cases"
+  - "Lifetime issues"
+  - "Unsafe code pitfalls"
+
+values:
+  # Ownership
+  move_after_use:
+    code: |
+      let s = String::from("hello");
+      let s2 = s;
+      println!("{}", s);  // Error
+    issue: "Use after move"
+    bugs_caught:
+      - "Value moved, then used"
+    safe_for_automation: true
+
+  partial_move:
+    code: |
+      struct Point { x: i32, y: i32 }
+      let p = Point { x: 1, y: 2 };
+      let x = p.x;
+      println!("{:?}", p);  // Error
+    issue: "Partial move makes struct unusable"
+    bugs_caught:
+      - "Partial move of struct"
+    safe_for_automation: true
+
+  # Borrowing
+  mutable_while_borrowed:
+    code: |
+      let mut v = vec![1, 2, 3];
+      let first = &v[0];
+      v.push(4);  // Error
+      println!("{}", first);
+    issue: "Mutable borrow while immutable borrow exists"
+    bugs_caught:
+      - "Borrow checker violation"
+    safe_for_automation: true
+
+  iterator_invalidation:
+    code: |
+      let mut v = vec![1, 2, 3];
+      for i in &v {
+          v.push(*i);  // Error
+      }
+    issue: "Modification during iteration"
+    bugs_caught:
+      - "Iterator invalidation"
+    safe_for_automation: true
+
+  # Lifetimes
+  dangling_reference:
+    code: |
+      fn dangle() -> &String {
+          let s = String::from("hello");
+          &s  // Error: returns reference to dropped value
+      }
+    issue: "Returning reference to local"
+    bugs_caught:
+      - "Dangling reference"
+    safe_for_automation: true
+
+  lifetime_elision_surprise:
+    code: |
+      fn longest(x: &str, y: &str) -> &str {
+          if x.len() > y.len() { x } else { y }
+      }  // Error: need lifetime annotations
+    issue: "Lifetime elision rules don't apply"
+    bugs_caught:
+      - "Missing lifetime annotation"
+    safe_for_automation: true
+
+  # Option/Result
+  unwrap_none:
+    code: |
+      let x: Option<i32> = None;
+      x.unwrap();  // Panic!
+    issue: "Unwrap on None"
+    bugs_caught:
+      - "Panicking on None"
+    safe_for_automation: true
+
+  unwrap_err:
+    code: |
+      let x: Result<i32, &str> = Err("oops");
+      x.unwrap();  // Panic!
+    issue: "Unwrap on Err"
+    bugs_caught:
+      - "Panicking on Err"
+    safe_for_automation: true
+
+  # Integer overflow
+  overflow_debug:
+    code: |
+      let x: u8 = 255;
+      let y = x + 1;  // Panic in debug, wrap in release
+    issue: "Integer overflow"
+    bugs_caught:
+      - "Different behavior debug vs release"
+    safe_for_automation: true
+
+  # Unsafe
+  unsafe_deref_null:
+    code: |
+      let ptr: *const i32 = std::ptr::null();
+      unsafe { *ptr }  // Undefined behavior
+    issue: "Null pointer dereference"
+    bugs_caught:
+      - "UB in unsafe code"
+    safe_for_automation: true
+
+  data_race_unsafe:
+    code: |
+      static mut COUNTER: i32 = 0;
+      // Multiple threads accessing COUNTER
+    issue: "Data race in unsafe static"
+    bugs_caught:
+      - "Data race with mutable static"
+    safe_for_automation: true
+
+  # String/str
+  string_indexing:
+    code: |
+      let s = String::from("hello");
+      let c = s[0];  // Error: cannot index String
+    issue: "Direct string indexing not allowed"
+    bugs_caught:
+      - "UTF-8 aware string handling"
+    safe_for_automation: true
+
+  string_slice_boundary:
+    code: |
+      let s = "héllo";
+      let slice = &s[0..2];  // Panic if not char boundary
+    issue: "Slice not on char boundary"
+    bugs_caught:
+      - "Multi-byte character slicing"
+    safe_for_automation: true

package/skills/bug-magnet-data/data/numbers/boundaries.yaml

@@ -0,0 +1,161 @@
+metadata:
+  version: "1.0.0"
+  last_updated: "2026-02-01"
+  source_urls: []
+
+category: numbers
+subcategory: boundaries
+tier: T0
+
+bugs_caught:
+  - "Integer overflow/underflow"
+  - "Off-by-one errors"
+  - "Division by zero"
+  - "Sign handling errors"
+
+values:
+  zero:
+    value: 0
+    bugs_caught:
+      - "Division by zero"
+      - "Zero-index edge cases"
+      - "Falsy value handling"
+    safe_for_automation: true
+
+  negative_one:
+    value: -1
+    bugs_caught:
+      - "Array index -1 handling"
+      - "Invalid count/size"
+      - "Error return value"
+    safe_for_automation: true
+
+  positive_one:
+    value: 1
+    bugs_caught:
+      - "Minimum positive handling"
+      - "Off-by-one at lower bound"
+    safe_for_automation: true
+
+  negative_zero:
+    value: -0
+    bugs_caught:
+      - "Signed zero handling"
+      - "Comparison with zero"
+    safe_for_automation: true
+    note: "In IEEE 754, -0 === 0 but 1/-0 === -Infinity"
+
+  # 32-bit integer boundaries
+  int32_max:
+    value: 2147483647
+    bugs_caught:
+      - "32-bit integer overflow"
+      - "INT_MAX handling"
+    safe_for_automation: true
+    note: "2^31 - 1"
+
+  int32_max_plus_1:
+    value: 2147483648
+    bugs_caught:
+      - "32-bit overflow to negative"
+    safe_for_automation: true
+    note: "2^31 - overflows to -2147483648 in signed 32-bit"
+
+  int32_min:
+    value: -2147483648
+    bugs_caught:
+      - "32-bit integer underflow"
+      - "INT_MIN handling"
+    safe_for_automation: true
+    note: "-2^31"
+
+  int32_min_minus_1:
+    value: -2147483649
+    bugs_caught:
+      - "32-bit underflow"
+    safe_for_automation: true
+
+  # 64-bit integer boundaries
+  int64_max:
+    value: 9223372036854775807
+    bugs_caught:
+      - "64-bit integer overflow"
+      - "LONG_MAX handling"
+    safe_for_automation: true
+    note: "2^63 - 1"
+
+  int64_min:
+    value: -9223372036854775808
+    bugs_caught:
+      - "64-bit integer underflow"
+      - "LONG_MIN handling"
+    safe_for_automation: true
+    note: "-2^63"
+
+  # Unsigned boundaries
+  uint32_max:
+    value: 4294967295
+    bugs_caught:
+      - "Unsigned 32-bit max"
+      - "UINT_MAX handling"
+    safe_for_automation: true
+    note: "2^32 - 1"
+
+  uint64_max:
+    value: 18446744073709551615
+    bugs_caught:
+      - "Unsigned 64-bit max"
+    safe_for_automation: true
+    note: "2^64 - 1"
+
+  # JavaScript safe integer
+  js_max_safe_int:
+    value: 9007199254740991
+    bugs_caught:
+      - "JavaScript precision loss"
+      - "Number.MAX_SAFE_INTEGER"
+    safe_for_automation: true
+    note: "2^53 - 1"
+
+  js_max_safe_int_plus_1:
+    value: 9007199254740992
+    bugs_caught:
+      - "JavaScript precision loss at boundary"
+    safe_for_automation: true
+    note: "2^53 - loses precision"
+
+  # Common business boundaries
+  hundred:
+    value: 100
+    bugs_caught:
+      - "Percentage boundary"
+      - "Hundred-based calculations"
+    safe_for_automation: true
+
+  thousand:
+    value: 1000
+    bugs_caught:
+      - "Thousand separator handling"
+    safe_for_automation: true
+
+  million:
+    value: 1000000
+    bugs_caught:
+      - "Large number display"
+    safe_for_automation: true
+
+  # Off-by-one patterns
+  power_of_2_minus_1:
+    value: 255
+    bugs_caught:
+      - "8-bit boundary"
+      - "Color value max"
+    safe_for_automation: true
+    note: "2^8 - 1"
+
+  power_of_2:
+    value: 256
+    bugs_caught:
+      - "8-bit overflow"
+    safe_for_automation: true
+    note: "2^8"

package/skills/bug-magnet-data/data/numbers/precision.yaml

@@ -0,0 +1,89 @@
+metadata:
+  version: "1.0.0"
+  last_updated: "2026-02-01"
+  source_urls: []
+
+category: numbers
+subcategory: precision
+tier: T1
+
+bugs_caught:
+  - "Floating point comparison failures"
+  - "Rounding errors in calculations"
+  - "Currency calculation bugs"
+
+values:
+  classic_float_fail:
+    expression: "0.1 + 0.2"
+    expected: 0.3
+    actual: 0.30000000000000004
+    bugs_caught:
+      - "Direct float comparison"
+      - "Classic IEEE 754 demonstration"
+    safe_for_automation: true
+
+  float_subtraction:
+    expression: "0.3 - 0.1"
+    expected: 0.2
+    actual: 0.19999999999999998
+    bugs_caught:
+      - "Float subtraction precision"
+    safe_for_automation: true
+
+  currency_penny:
+    value: 0.01
+    bugs_caught:
+      - "Currency precision (use integers for cents)"
+    safe_for_automation: true
+
+  currency_calculation:
+    expression: "19.99 * 100"
+    expected: 1999
+    actual: 1998.9999999999998
+    bugs_caught:
+      - "Currency multiplication precision"
+    safe_for_automation: true
+
+  very_small:
+    value: 1e-300
+    bugs_caught:
+      - "Very small number handling"
+      - "Underflow risks"
+    safe_for_automation: true
+
+  very_large:
+    value: 1e300
+    bugs_caught:
+      - "Very large number handling"
+      - "Overflow risks"
+    safe_for_automation: true
+
+  recurring_decimal:
+    expression: "1 / 3"
+    bugs_caught:
+      - "Repeating decimal representation"
+    safe_for_automation: true
+
+  division_precision:
+    expression: "10 / 3 * 3"
+    expected: 10
+    actual: 9.999999999999998
+    bugs_caught:
+      - "Division-multiplication precision loss"
+    safe_for_automation: true
+
+  sum_many_small:
+    expression: "0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1"
+    expected: 1.0
+    actual: 0.9999999999999999
+    bugs_caught:
+      - "Accumulated rounding errors"
+    safe_for_automation: true
+
+  percentage_of_percentage:
+    expression: "100 * 0.7 * 0.7"
+    expected: 49
+    actual: 48.99999999999999
+    bugs_caught:
+      - "Compound percentage calculations"
+    safe_for_automation: true

package/skills/bug-magnet-data/data/numbers/special.yaml

@@ -0,0 +1,69 @@
+metadata:
+  version: "1.0.0"
+  last_updated: "2026-02-01"
+  source_urls: []
+
+category: numbers
+subcategory: special
+tier: T1
+
+bugs_caught:
+  - "NaN propagation"
+  - "Infinity handling"
+  - "Special value comparisons"
+
+values:
+  nan:
+    value: "NaN"
+    bugs_caught:
+      - "NaN !== NaN comparison failure"
+      - "NaN propagation through calculations"
+      - "isNaN vs Number.isNaN confusion"
+    safe_for_automation: true
+    note: "Use Number.isNaN() not isNaN()"
+
+  positive_infinity:
+    value: "Infinity"
+    bugs_caught:
+      - "Infinite loop risks"
+      - "Display of infinite values"
+      - "Comparison with Infinity"
+    safe_for_automation: true
+
+  negative_infinity:
+    value: "-Infinity"
+    bugs_caught:
+      - "Negative infinity handling"
+      - "Min value calculations"
+    safe_for_automation: true
+
+  epsilon:
+    value: 2.220446049250313e-16
+    bugs_caught:
+      - "Floating point comparison threshold"
+    safe_for_automation: true
+    note: "Number.EPSILON in JavaScript"
+
+  max_value:
+    value: 1.7976931348623157e+308
+    bugs_caught:
+      - "Maximum float value"
+      - "Overflow to Infinity"
+    safe_for_automation: true
+    note: "Number.MAX_VALUE in JavaScript"
+
+  min_value:
+    value: 5e-324
+    bugs_caught:
+      - "Minimum positive float"
+      - "Underflow to zero"
+    safe_for_automation: true
+    note: "Number.MIN_VALUE in JavaScript (positive)"
+
+  min_safe_integer:
+    value: -9007199254740991
+    bugs_caught:
+      - "Minimum safe integer"
+      - "Precision loss below this"
+    safe_for_automation: true
+    note: "-(2^53 - 1)"

package/skills/bug-magnet-data/data/strings/boundaries.yaml

@@ -0,0 +1,109 @@
+metadata:
+  version: "1.0.0"
+  last_updated: "2026-02-01"
+  source_urls: []
+
+category: strings
+subcategory: boundaries
+tier: T0
+
+bugs_caught:
+  - "NullPointerException on empty input"
+  - "Off-by-one in length validation"
+  - "Buffer overflow on long strings"
+  - "Whitespace-only treated as empty"
+
+values:
+  empty:
+    value: ""
+    bugs_caught:
+      - "NullPointerException"
+      - "Empty input not handled"
+      - "Length validation off-by-one"
+    safe_for_automation: true
+
+  single_char:
+    value: "a"
+    bugs_caught:
+      - "Minimum length validation"
+      - "Single vs empty distinction"
+    safe_for_automation: true
+
+  two_chars:
+    value: "ab"
+    bugs_caught:
+      - "Off-by-one at minimum boundary"
+    safe_for_automation: true
+
+  whitespace_only:
+    value: "   "
+    bugs_caught:
+      - "Trim logic errors"
+      - "Empty vs whitespace distinction"
+    safe_for_automation: true
+
+  single_space:
+    value: " "
+    bugs_caught:
+      - "Space handling"
+      - "Trim edge case"
+    safe_for_automation: true
+
+  tabs_and_spaces:
+    value: "\t  \t"
+    bugs_caught:
+      - "Mixed whitespace handling"
+      - "Inconsistent trim behavior"
+    safe_for_automation: true
+
+  leading_whitespace:
+    value: "  hello"
+    bugs_caught:
+      - "Left trim failures"
+      - "Whitespace preservation bugs"
+    safe_for_automation: true
+
+  trailing_whitespace:
+    value: "hello  "
+    bugs_caught:
+      - "Right trim failures"
+      - "Trailing space handling"
+    safe_for_automation: true
+
+  long_string_1000:
+    value_template: "a * 1000"
+    bugs_caught:
+      - "Performance degradation"
+      - "Memory allocation issues"
+    safe_for_automation: true
+    note: "Generate 1000 'a' characters"
+
+  long_string_10000:
+    value_template: "a * 10000"
+    bugs_caught:
+      - "Buffer limits"
+      - "Truncation errors"
+    safe_for_automation: true
+    note: "Generate 10000 'a' characters"
+
+  max_length_minus_1:
+    value_template: "a * (MAX_LENGTH - 1)"
+    bugs_caught:
+      - "Off-by-one at maximum"
+    safe_for_automation: true
+    note: "Use system-specific MAX_LENGTH"
+
+  max_length:
+    value_template: "a * MAX_LENGTH"
+    bugs_caught:
+      - "Exact boundary handling"
+    safe_for_automation: true
+    note: "Use system-specific MAX_LENGTH"
+
+  max_length_plus_1:
+    value_template: "a * (MAX_LENGTH + 1)"
+    bugs_caught:
+      - "Overflow at maximum"
+      - "Rejection message quality"
+    safe_for_automation: true
+    note: "Use system-specific MAX_LENGTH"