json-repair 0.7.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdf2958528b936eba0faf6c724a20d10a3a3e0b95329bc1866740c99432f6fe3
-  data.tar.gz: 33fa97d2c7689ea594723e5d0d412646cf57a2ebdbf79f3b62947d4928963f32
+  metadata.gz: 0c130bbea1b9299e31e5bfa8db873b09fd911715b7125fda6ee60a101353be5f
+  data.tar.gz: 80f6e2fe16669210505e45c99a443eaa3ce6b8b3c10e3967633885f91a9d057b
 SHA512:
-  metadata.gz: 587323c57caac3e53af1da24cfeee47df18ff738516d8fd2862d37a547c6e864cf5653c8b43427ec58aa47be3f2e958c991208b36de098c5ffc9503f2c64a0a2
-  data.tar.gz: f5380cfdca6a4f60833ab57fc8465715b546415fa4f6ed5781b6bb24653ce324d2b6d928f9a5ff87b4deead145391303c1e805bf0fbff238b9ef1c7024a1f4aa
+  metadata.gz: 4e2c05c45ebf1cf149705021faa611c22e6e2e0de48d15d2496da4e935291abe6bf185cde756263c6aad210f73ca2e54e4c965826b14bdbb0fa9ffa47bf1684f
+  data.tar.gz: 180b477cea0b27c813b664bfcda75eb28b59453d1fe4ce90781cf298c870aa8518411e689a37ddc30882aa5f376c351ff718600411d97df845f67fd87b593d92

data/.rubocop.yml

@@ -1,10 +1,6 @@
 AllCops:
   TargetRubyVersion: 3.0
 
-Metrics/BlockLength:
-  Exclude:
-    - spec/**/*
-
 Style/Documentation:
   Enabled: false
 
@@ -33,6 +29,8 @@ Metrics/BlockLength:
   Exclude:
     - lib/json/repairer.rb
     - spec/**/*
+    # restore RuboCop's default exclusion, lost when Exclude is overridden
+    - '*.gemspec'
 
 Metrics/BlockNesting:
   Exclude:

data/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changes
 
+### 2026-06-12 (0.11.0)
+
+* Repair object string values with unescaped quotes around a colon
+  ("doubled colon"): `{"a": "b": "c"}` → `{"a":"b\": \"c"}` — the
+  value reads as `b": "c`, the unescaped-quotes interpretation. The
+  merge preserves the literal characters between the strings
+  (whitespace, original quote style) and repeats greedily
+  (`{"a": "b": "c": "d"}` → value `b": "c": "d`). Only the
+  string–colon–string shape is repaired: non-string shapes like
+  `{"a": "b": 1}` or `{"a": 1: 2}` still raise `JSONRepairError`
+  rather than silently dropping data (Python `json_repair` drops the
+  `: 1` there). Previously all of these raised "Object key expected".
+  Deliberate divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (raises as of
+  v3.14.0), matching
+  [Go json-repair](https://github.com/RealAlexandreAI/json-repair)
+  and Python
+  [`json_repair`](https://github.com/mangiucugna/json_repair) on the
+  canonical case.
+
+### 2026-06-11 (0.10.0)
+
+* Repair Markdown list markers in front of top-level values:
+  `- {"a": 1}` → `{"a":1}`, and multi-line lists become arrays via the
+  existing newline-delimited JSON handling
+  (`"- {\"a\": 1}\n- {\"b\": 2}"` → `[{"a":1},{"b":2}]`). Bullet
+  markers `-`, `*`, `+` and ordered markers like `1.` / `2)` (up to
+  nine digits, the CommonMark limit) are recognized at the start of
+  the root value and of each newline-delimited line, only when
+  followed by same-line whitespace and a value — so `-5`, a trailing
+  `"- "`, and newline-delimited decimals like `"1.5\n2.5"` keep their
+  number readings, and nothing changes inside nested structures.
+  Previously these inputs raised `JSONRepairError`; two non-raising
+  behaviors change for the better: `"3\n- 5\n7"` now repairs to
+  `[3,5,7]` instead of the corrupt `[3,0,5,7]`, and a single-line
+  `* text` becomes `"text"` instead of `"* text"`. Deliberate
+  divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (no Markdown
+  list handling as of v3.14.0), and more precise than Python
+  [`json_repair`](https://github.com/mangiucugna/json_repair), which
+  collapses scalar list items to `""`.
+
+### 2026-06-11 (0.9.0)
+
+* Repair numbers missing the digit before their decimal point:
+  `.5` → `0.5`, `-.5` → `-0.5`, and truncated forms like `.` → `0.0`.
+  Previously these leaked a raw stdlib `JSON::ParserError` out of
+  `JSON.repair` because the repairer emitted the leading-dot number
+  unchanged (invalid JSON) and the canonical-output re-parse choked on
+  it. This is a deliberate divergence from upstream
+  [jsonrepair](https://github.com/josdejong/jsonrepair) (which leaves
+  leading-dot numbers unrepaired as of v3.14.0), matching
+  [dirty-json](https://github.com/RyanMarcus/dirty-json) behavior.
+* `JSON.repair` now guards its error contract: if the repairer ever
+  emits a string stdlib JSON cannot parse (a repairer bug), the stdlib
+  error is wrapped in `JSON::JSONRepairError` instead of leaking
+  `JSON::ParserError` to callers.
+
+### 2026-05-15 (0.8.0)
+
+* `JSON.repair_file(path)` and `JSON.repair_io(io)` convenience
+  wrappers around `JSON.repair`. `repair_file` reads a path from disk
+  (accepts a `String` or `Pathname`); `repair_io` reads from any
+  object responding to `#read` (e.g. `File`, `StringIO`, `$stdin`)
+  without closing it. Both forward `return_objects:` and
+  `skip_json_loads:` through to `JSON.repair`. Mirrors Python's
+  [`json_repair`](https://github.com/mangiucugna/json_repair)
+  `load` / `from_file` helpers.
+
 ### 2026-05-12 (0.7.0)
 
 * `JSON.repair` now always returns canonical JSON via

data/CLAUDE.md

@@ -10,7 +10,8 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - `bundle exec rspec spec/json_spec.rb:42` — run a single example by line number; nearly all behavioral specs live in `spec/json_spec.rb`.
 - `bundle exec rubocop` — lint. Project-specific exclusions in `.rubocop.yml` deliberately disable several `Metrics/*` cops for `lib/json/repairer.rb` and `lib/json/repair/string_utils.rb` because the parser is long by design — don't try to "fix" it by chopping methods up.
 - `bin/console` — IRB with the gem preloaded.
-- `bundle exec rake install` / `bundle exec rake release` — local install / publish to rubygems.org.
+- `bundle exec rake bench` — benchmark-ips regression baseline (`benchmark/run.rb`); run before/after perf-sensitive changes.
+- `bundle exec rake install` / `bundle exec rake release` — local install / publish to rubygems.org (release prompts for a rubygems MFA OTP).
 - Type checking: `Steepfile` checks `lib/` against `sig/`. `bundle exec steep check` (typecheck) and `bundle exec rbs validate` (sig syntax) both run in CI and as part of the default rake task. `steep` and `rbs` are dev dependencies in the `Gemfile`.
 
 Ruby `>= 3.0.0` is required (per gemspec). CI runs against Ruby 3.3.1.
@@ -19,9 +20,15 @@ Ruby `>= 3.0.0` is required (per gemspec). CI runs against Ruby 3.3.1.
 
 This gem is a **Ruby port of the [josdejong/jsonrepair](https://github.com/josdejong/jsonrepair) TypeScript library**. The upstream version currently mirrored is tracked in `CHANGELOG.md` (presently v3.14.0). When syncing upstream changes, the goal is parity with the JS implementation, not idiomatic refactoring — keep method names, control flow, and repair heuristics aligned with the JS source so future syncs stay tractable.
 
+A few repair heuristics deliberately go **beyond** upstream (leading-dot numbers like `.5`, Markdown list markers like `- {...}`). Each such site carries a "Divergence from upstream" comment in the code and a CHANGELOG note — keep that convention when adding more, so future upstream syncs can tell ported behavior from local extensions.
+
 ### Entry point
 
-`JSON.repair(str)` in `lib/json/repair.rb` is a thin wrapper that constructs `JSON::Repairer.new(str).repair`. `JSON::JSONRepairError` is the only error raised for unrecoverable inputs.
+`JSON.repair(str)` in `lib/json/repair.rb` first tries stdlib `JSON.parse` (fast path; opt out with `skip_json_loads: true`), and falls back to `JSON::Repairer.new(str).repair` when that raises. Either way the result is re-serialized with `JSON.generate`, so **output is canonical** — whitespace collapsed, numbers normalized, duplicate keys last-write-wins — and both paths agree on it. A `REPAIR_REQUIRED_PATTERN` regex routes inputs containing comments or invalid escapes straight to the Repairer even though the bundled `json` gem would accept them. `return_objects: true` returns the parsed Ruby value instead of a string; `JSON.repair_file(path)` / `JSON.repair_io(io)` are convenience wrappers forwarding both options.
+
+`JSON::JSONRepairError` is the only error raised for unrecoverable inputs; it exposes the failure `#position`. If the Repairer ever emits a string stdlib cannot parse (a Repairer bug), the `JSON::ParserError` is wrapped in `JSONRepairError` rather than leaked.
+
+`exe/json-repair` is a CLI wrapper (`lib/json/repair/cli.rb`) reading stdin or a file, writing stdout, `--output FILE`, or `--overwrite`.
 
 ### The parser (`lib/json/repairer.rb`)
 
@@ -43,7 +50,7 @@ Two patterns recur and are worth knowing before editing:
 - **Backtracking via snapshots.** Methods like `parse_string` capture `i_before = @index` and `o_before = @output.length` before tentatively consuming input. If a later check (e.g. "the end quote turned out not to be a real end quote") fails, they restore both and re-invoke themselves with different flags (e.g. `stop_at_delimiter: true`, `stop_at_index: …`). Preserve this pattern when modifying string/number parsing.
 - **Repair-by-rewriting-tail.** Helpers like `insert_before_last_whitespace(@output, ',')` and `@output = strip_last_occurrence(@output, ',')` patch the already-emitted output to fix things like missing or trailing commas. These run *after* the malformed input has been partially emitted — they are the mechanism for "I now realize that earlier token needed a comma after it."
 
-`repair` (the public method) drives `parse_value` then handles top-level concerns: stripping Markdown fences (` ```json ... ``` `), converting newline-delimited JSON at the root into an array, dropping redundant trailing braces/brackets, and rejecting any non-whitespace trailing garbage.
+`repair` (the public method) drives `parse_value` then handles top-level concerns: stripping Markdown fences (` ```json ... ``` `), skipping Markdown list markers like `- ` / `* ` / `1. ` before the root value and each newline-delimited line (`markdown_list_marker_length` / `skip_markdown_list_marker` — top-level only, never inside nested structures), converting newline-delimited JSON at the root into an array, dropping redundant trailing braces/brackets, and rejecting any non-whitespace trailing garbage.
 
 ### Shared helpers (`lib/json/repair/string_utils.rb`)
 
@@ -62,6 +69,13 @@ RBS signatures mirror the public surface of `JSON.repair`, `JSON::Repairer`, and
 
 ### Test layout
 
-- `spec/json_spec.rb` — the substantive behavioral suite (700+ examples covering every repair heuristic). New behavior — and every sync from upstream — belongs here.
+- `spec/json_spec.rb` — the substantive behavioral suite (130+ examples, hundreds of assertions, covering every repair heuristic). New behavior — and every sync from upstream — belongs here.
+- `spec/json/repair/cli_spec.rb` — the `exe/json-repair` CLI (argument handling, IO errors, exit codes).
+- `spec/json/repair/string_utils_spec.rb` — direct unit coverage for a few `StringUtils` edge cases the behavioral suite can't reach.
 - `spec/json/repair_spec.rb` — sanity check on `JSON::Repair::VERSION` only.
-- `.rspec_status` is committed and tracks per-example pass/fail so `--only-failures` / `--next-failure` work across runs.
+- SimpleCov enforces 100% line and branch coverage on the full run, so a filtered `rspec -e ...` run "fails" at the coverage gate even when all selected examples pass — ignore that exit code during TDD.
+- `.rspec_status` is gitignored (local pass/fail tracking for `--only-failures` / `--next-failure`).
+
+## Local planning notes
+
+`docs/` (the `TODO.md` backlog plus design specs and implementation plans under `docs/superpowers/`) is gitignored local planning material — read it for context, update it as work completes, but never commit anything under `docs/`.

data/README.md

@@ -4,7 +4,7 @@ This is a Ruby gem designed to repair broken JSON strings. Inspired by and based
 
 ## Installation
 
-Add this gem to your application's Gemfield by executing:
+Add this gem to your application's Gemfile by executing:
 
 ```bash
 $ bundle add json-repair
@@ -31,6 +31,18 @@ puts repaired_json  # Outputs: {"name":"Alice","age":25}
 
 The `repair` method takes a string containing JSON data and returns a corrected version of this string, ensuring it is valid JSON.
 
+Markdown markup in LLM output is handled too: fenced code blocks like `` ```json `` are stripped, and list markers (`-`, `*`, `+`, `1.`) in front of top-level values are removed — a multi-line list becomes an array:
+
+```ruby
+JSON.repair("- {\"a\": 1}\n- {\"b\": 2}")  # => '[{"a":1},{"b":2}]'
+```
+
+Object values containing unescaped quotes around a colon are merged back into a single string value:
+
+```ruby
+JSON.repair('{"a": "b": "c"}')  # => '{"a":"b\": \"c"}' — the value reads as 'b": "c'
+```
+
 Pass `return_objects: true` to get the parsed Ruby value (Hash, Array, or scalar) instead of a string:
 
 ```ruby
@@ -53,6 +65,20 @@ If you need the parsed Ruby value instead of a string, pass `return_objects: tru
 
 `skip_json_loads: true` skips the stdlib `JSON.parse` attempt and routes the input straight through the repairer. The output is the same; the option is purely a performance knob for callers who know their input will need repair.
 
+### Reading from a file or IO
+
+`JSON.repair_file(path)` reads a file from disk and repairs its contents. `JSON.repair_io(io)` does the same with any object that responds to `#read` (e.g. `File`, `StringIO`, `$stdin`). Both forward `return_objects:` and `skip_json_loads:` to `JSON.repair`.
+
+```ruby
+JSON.repair_file('broken.json')
+JSON.repair_file('broken.json', return_objects: true)
+
+File.open('broken.json') { |io| JSON.repair_io(io) }
+JSON.repair_io($stdin)
+```
+
+`JSON.repair_io` does not close the IO — the caller manages its lifecycle.
+
 ## Command line
 
 The gem ships a `json-repair` executable. It reads from stdin or a file and writes to stdout, `--output FILE`, or back over the input file with `--overwrite`.

data/Rakefile

@@ -19,6 +19,9 @@ task :steep do
   sh 'bundle exec steep check'
 end
 
+desc 'Type-check: rbs validate + steep check'
+task typecheck: %i[rbs steep]
+
 desc 'Run benchmark/run.rb (regression baseline for JSON.repair)'
 task :bench do
   ruby '-Ilib', 'benchmark/run.rb'

data/lib/json/repair/string_utils.rb

@@ -60,13 +60,14 @@ module JSON
 
       # Functions to check character chars
       def hex?(char)
-        (char >= ZERO && char <= NINE) ||
-          (char >= UPPERCASE_A && char <= UPPERCASE_F) ||
-          (char >= LOWERCASE_A && char <= LOWERCASE_F)
+        !char.nil? &&
+          ((char >= ZERO && char <= NINE) ||
+           (char >= UPPERCASE_A && char <= UPPERCASE_F) ||
+           (char >= LOWERCASE_A && char <= LOWERCASE_F))
       end
 
       def digit?(char)
-        char && char >= ZERO && char <= NINE
+        !char.nil? && char >= ZERO && char <= NINE
       end
 
       def valid_string_character?(char)
@@ -74,11 +75,11 @@ module JSON
       end
 
       def delimiter?(char)
-        REGEX_DELIMITER.match?(char)
+        !char.nil? && REGEX_DELIMITER.match?(char)
       end
 
       def unquoted_string_delimiter?(char)
-        REGEX_UNQUOTED_STRING_DELIMITER.match?(char)
+        !char.nil? && REGEX_UNQUOTED_STRING_DELIMITER.match?(char)
       end
 
       REGEX_FUNCTION_NAME_CHAR_START = /\A[a-zA-Z_$]\z/
@@ -93,19 +94,19 @@ module JSON
       end
 
       def start_of_value?(char)
-        REGEX_START_OF_VALUE.match?(char) || (char && quote?(char))
+        !char.nil? && (REGEX_START_OF_VALUE.match?(char) || quote?(char))
       end
 
       def control_character?(char)
-        [NEWLINE, RETURN, TAB, BACKSPACE, FORM_FEED].include?(char)
+        !char.nil? && [NEWLINE, RETURN, TAB, BACKSPACE, FORM_FEED].include?(char)
       end
 
       def whitespace?(char)
-        [SPACE, NEWLINE, TAB, RETURN].include?(char)
+        !char.nil? && [SPACE, NEWLINE, TAB, RETURN].include?(char)
       end
 
       def whitespace_except_newline?(char)
-        [SPACE, TAB, RETURN].include?(char)
+        !char.nil? && [SPACE, TAB, RETURN].include?(char)
       end
 
       def special_whitespace?(char)
@@ -122,6 +123,14 @@ module JSON
           (char >= EN_QUAD && char <= ZERO_WIDTH_SPACE)
       end
 
+      def same_line_whitespace?(char)
+        whitespace_except_newline?(char) || special_whitespace?(char)
+      end
+
+      def whitespace_or_special?(char)
+        whitespace?(char) || special_whitespace?(char)
+      end
+
       def quote?(char)
         double_quote_like?(char) || single_quote_like?(char)
       end
@@ -135,20 +144,25 @@ module JSON
       end
 
       def double_quote_like?(char)
-        [DOUBLE_QUOTE, DOUBLE_QUOTE_LEFT, DOUBLE_QUOTE_RIGHT].include?(char)
+        !char.nil? && [DOUBLE_QUOTE, DOUBLE_QUOTE_LEFT, DOUBLE_QUOTE_RIGHT].include?(char)
       end
 
       def single_quote_like?(char)
-        [QUOTE, QUOTE_LEFT, QUOTE_RIGHT, GRAVE_ACCENT, ACUTE_ACCENT].include?(char)
+        !char.nil? && [QUOTE, QUOTE_LEFT, QUOTE_RIGHT, GRAVE_ACCENT, ACUTE_ACCENT].include?(char)
       end
 
-      # Strip last occurrence of text_to_strip from text
+      # Strip last occurrence of text_to_strip from text.
+      #
+      # `|| ''` on the slices below (and in `insert_before_last_whitespace` /
+      # `remove_at_index`) is for steep's nil-narrowing: `String#[range]` is
+      # typed `String?`, but every call site here keeps indices within
+      # `0..text.length`, so the slices never actually return `nil`.
       def strip_last_occurrence(text, text_to_strip, strip_remaining_text: false)
         index = text.rindex(text_to_strip)
         return text unless index
 
-        remaining_text = strip_remaining_text ? '' : text[index + 1..]
-        text[0...index] + remaining_text
+        remaining_text = strip_remaining_text ? '' : (text[index + 1..] || '')
+        (text[0...index] || '') + remaining_text
       end
 
       def insert_before_last_whitespace(text, text_to_insert)
@@ -158,7 +172,7 @@ module JSON
 
         index -= 1 while whitespace?(text[index - 1])
 
-        text[0...index] + text_to_insert + text[index..]
+        (text[0...index] || '') + text_to_insert + (text[index..] || '')
       end
 
       # Parse keywords true, false, null
@@ -187,7 +201,7 @@ module JSON
       end
 
       def remove_at_index(text, start, count)
-        text[0...start] + text[start + count..]
+        (text[0...start] || '') + (text[start + count..] || '')
       end
 
       def ends_with_comma_or_newline?(text)

data/lib/json/repair/version.rb

@@ -2,6 +2,6 @@
 
 module JSON
   module Repair
-    VERSION = '0.7.0'
+    VERSION = '0.11.0'
   end
 end

data/lib/json/repair.rb

@@ -20,6 +20,22 @@ module JSON
     return_objects ? parsed : JSON.generate(parsed)
   end
 
+  # Inlined rather than calling `repair(...)` so the literal-bool overloads
+  # in sig/json/repair.rbs narrow correctly per caller — forwarding a
+  # `bool`-typed `return_objects` will not resolve against the literal-
+  # `true`/`false` overloads on `JSON.repair`.
+  def self.repair_io(io, return_objects: false, skip_json_loads: false)
+    json = io.read || ''
+    parsed = skip_json_loads ? repaired_parse(json) : tolerant_parse(json)
+    return_objects ? parsed : JSON.generate(parsed)
+  end
+
+  def self.repair_file(path, return_objects: false, skip_json_loads: false)
+    json = File.read(path.to_s)
+    parsed = skip_json_loads ? repaired_parse(json) : tolerant_parse(json)
+    return_objects ? parsed : JSON.generate(parsed)
+  end
+
   def self.tolerant_parse(json)
     JSON.parse(json)
   rescue JSON::ParserError
@@ -27,8 +43,14 @@ module JSON
   end
   private_class_method :tolerant_parse
 
+  # The rescue guards the JSONRepairError-only error contract: if the
+  # Repairer ever emits a string stdlib JSON cannot parse (a Repairer bug),
+  # wrap the stdlib error instead of leaking JSON::ParserError to callers.
   def self.repaired_parse(json)
-    JSON.parse(Repairer.new(json).repair)
+    repaired = Repairer.new(json).repair
+    JSON.parse(repaired)
+  rescue JSON::ParserError => e
+    raise JSONRepairError, "Internal error: repaired output is not valid JSON (#{e.message})"
   end
   private_class_method :repaired_parse
 end

data/lib/json/repairer.rb

@@ -37,6 +37,12 @@ module JSON
     def repair
       parse_markdown_code_block(MARKDOWN_OPEN_BLOCKS)
 
+      # repair: skip a Markdown list marker before the root value
+      # (and any comments before it, which parse_value would otherwise
+      # only consume after the marker check has already failed)
+      parse_whitespace_and_skip_comments
+      skip_markdown_list_marker
+
       processed = parse_value
 
       throw_unexpected_end unless processed
@@ -46,7 +52,8 @@ module JSON
       processed_comma = parse_character(COMMA)
       parse_whitespace_and_skip_comments if processed_comma
 
-      if start_of_value?(@json[@index]) && ends_with_comma_or_newline?(@output)
+      if (start_of_value?(@json[@index]) || markdown_list_marker_length) &&
+         ends_with_comma_or_newline?(@output)
         # start of a new value after end of the root level object: looks like
         # newline delimited JSON -> turn into a root level array
         unless processed_comma
@@ -170,6 +177,52 @@ module JSON
       false
     end
 
+    # Look ahead from @index for a Markdown list marker like "- ", "* ",
+    # "+ ", or "12. " that precedes a value. Returns the marker's length,
+    # or nil when there is no marker. Only consulted at the top level —
+    # the root value and each newline-delimited value — never inside
+    # nested structures. A marker must be followed by same-line
+    # whitespace and a value, so "-5", a trailing "- ", and "-\n{...}"
+    # keep their number readings. Ordered markers are capped at nine
+    # digits (the CommonMark limit) so long truncated decimals are not
+    # mistaken for markers. Divergence from upstream (no Markdown list
+    # handling as of v3.14.0): LLMs frequently emit JSON values as
+    # Markdown list items.
+    def markdown_list_marker_length
+      j = @index
+
+      if [MINUS, ASTERISK, PLUS].include?(@json[j])
+        j += 1
+      elsif digit?(@json[j])
+        j += 1 while digit?(@json[j]) && j - @index < 9
+        return nil unless [DOT, CLOSE_PARENTHESIS].include?(@json[j])
+
+        j += 1
+      else
+        return nil
+      end
+
+      marker_length = j - @index
+      return nil unless same_line_whitespace?(@json[j])
+
+      j += 1 while same_line_whitespace?(@json[j])
+      # a leading-dot number like ".5" is also a value here: parse_number
+      # repairs it to "0.5" even though start_of_value? does not match it
+      return nil unless start_of_value?(@json[j]) || @json[j] == DOT
+
+      marker_length
+    end
+
+    # Repair a value behind a Markdown list marker, like "- {"a":1}",
+    # by skipping the marker. See markdown_list_marker_length.
+    def skip_markdown_list_marker
+      length = markdown_list_marker_length
+      return false unless length
+
+      @index += length
+      true
+    end
+
     # Parse an object like '{"key": "value"}'
     def parse_object
       return false unless @json[@index] == OPENING_BRACE
@@ -241,6 +294,10 @@ module JSON
           end
           # :nocov:
         end
+
+        # repair: an object string value with unescaped quotes around a
+        # colon, like {"a": "b": "c"}
+        repair_doubled_colon if processed_value
       end
 
       if @json[@index] == CLOSING_BRACE
@@ -254,6 +311,59 @@ module JSON
       true
     end
 
+    # Repair an object value with unescaped quotes around a colon, like
+    # {"a": "b": "c"}, by merging it all into one string value: 'b": "c'
+    # (the unescaped-quotes reading of the input). Greedy: keeps merging
+    # while another `: "..."` follows. Only the string-colon-string
+    # shape is repaired; anything else falls through to the regular
+    # error paths. Divergence from upstream (which raises "Object key
+    # expected" as of v3.14.0), matching the Go and Python json-repair
+    # libraries on the canonical case.
+    def repair_doubled_colon
+      loop do
+        colon = @index
+        # :nocov: kept for symmetry with the start_quote scan below; unreachable
+        # because @index never rests on whitespace here. On first entry,
+        # parse_value ends with parse_whitespace_and_skip_comments. On greedy
+        # re-entry, every parse_string exit leaves @index off-whitespace: the
+        # EOF path (nil is not whitespace), the stop_at_index path (a
+        # prev_non_whitespace_index position), and the end-quote path (ends in
+        # parse_concatenated_string, whose leading whitespace skip consumes
+        # newlines too). If a future parse_value/parse_string change breaks
+        # that, this scan becomes live and the :nocov: will hide it.
+        colon += 1 while whitespace_or_special?(@json[colon])
+        # :nocov:
+        return unless @json[colon] == COLON
+
+        # scan past special whitespace too (unlike prev_non_whitespace_index):
+        # parse_whitespace treats NBSP and friends as whitespace, so this
+        # repair should as well. The value's last character (at worst the
+        # object's opening brace) always stops the scan before index 0.
+        end_quote = colon - 1
+        end_quote -= 1 while whitespace_or_special?(@json[end_quote])
+        return unless quote?(@json[end_quote])
+
+        start_quote = colon + 1
+        start_quote += 1 while whitespace_or_special?(@json[start_quote])
+        return unless quote?(@json[start_quote])
+
+        # repair: replace the end quote already emitted (plus any copied
+        # trailing whitespace) with the literal input span from that end
+        # quote through the next start quote, escaped as string content
+        @output = strip_last_occurrence(@output, '"', strip_remaining_text: true)
+        @json[end_quote..start_quote].each_char do |char|
+          @output << (char == DOUBLE_QUOTE ? '\"' : CONTROL_CHARACTERS.fetch(char, char))
+        end
+
+        # let parse_string consume the rest of the merged string, then
+        # drop the start quote it emits (already emitted escaped above)
+        @index = start_quote
+        start = @output.length
+        parse_string
+        @output = remove_at_index(@output, start, 1)
+      end
+    end
+
     def skip_character(char)
       if @json[@index] == char
         @index += 1
@@ -570,7 +680,9 @@ module JSON
           repair_number_ending_with_numeric_symbol(start)
           return true
         end
-        unless digit?(@json[@index])
+        # also accept a dot so "-.5" continues into the fraction branch
+        # below (divergence from upstream, which leaves "-.5" unrepaired)
+        unless digit?(@json[@index]) || @json[@index] == DOT
           @index = start
           return false
         end
@@ -620,7 +732,7 @@ module JSON
         num = @json[start...@index]
         has_invalid_leading_zero = num.match?(/^0\d/)
 
-        @output << (has_invalid_leading_zero ? "\"#{num}\"" : num)
+        @output << (has_invalid_leading_zero ? "\"#{num}\"" : repair_leading_dot_number(num))
         return true
       end
 
@@ -711,7 +823,18 @@ module JSON
       # repair numbers cut off at the end
       # this will only be called when we end after a '.', '-', or 'e' and does not
       # change the number more than it needs to make it valid JSON
-      @output << "#{@json[start...@index]}0"
+      @output << repair_leading_dot_number("#{@json[start...@index]}0")
+    end
+
+    # Repair a number missing its digit before the decimal point, like ".5"
+    # or "-.5", into "0.5" / "-0.5". Divergence from upstream, which emits
+    # the invalid leading-dot number unchanged. The guard keeps the common
+    # case (a number that needs no repair) allocation-free; `sub` copies
+    # its receiver even when the pattern does not match.
+    def repair_leading_dot_number(num)
+      return num unless num.start_with?('.', '-.')
+
+      num.sub(/\A(?<sign>-?)\./, '\k<sign>0.')
     end
 
     # Parse and repair Newline Delimited JSON (NDJSON):
@@ -732,6 +855,10 @@ module JSON
           end
         end
 
+        # repair: skip a Markdown list marker before the next value
+        parse_whitespace_and_skip_comments
+        skip_markdown_list_marker
+
         processed_value = parse_value
       end
 

data/sig/json/repair/string_utils.rbs

@@ -1,9 +1,9 @@
 module JSON
   module Repair
     module StringUtils
-      @output: untyped
+      @output: ::String
 
-      @index: untyped
+      @index: ::Integer
 
       # Constants for character chars
       BACKSLASH: "\\"
@@ -24,17 +24,17 @@ module JSON
 
       CLOSE_PARENTHESIS: ")"
 
-      SPACE: " "
+      SPACE: ::String
 
-      NEWLINE: "\n"
+      NEWLINE: ::String
 
-      TAB: "\t"
+      TAB: ::String
 
-      RETURN: "\r"
+      RETURN: ::String
 
-      BACKSPACE: "\b"
+      BACKSPACE: ::String
 
-      FORM_FEED: "\f"
+      FORM_FEED: ::String
 
       DOUBLE_QUOTE: "\""
 
@@ -110,56 +110,64 @@ module JSON
 
       REGEX_FUNCTION_NAME_CHAR: ::Regexp
 
-      # Functions to check character chars
-      def hex?: (untyped char) -> untyped
+      # Functions to check character chars.
+      # `char` is `::String?` because every caller passes `@json[@index]`,
+      # which is `nil` past the end of input. The predicates either guard
+      # against `nil` explicitly or rely on `Array#include?` / `==` /
+      # `Regexp#match?` returning a safe value for `nil`.
+      def hex?: (::String? char) -> bool
 
-      def digit?: (untyped char) -> untyped
+      def digit?: (::String? char) -> bool
 
-      def valid_string_character?: (untyped char) -> untyped
+      def valid_string_character?: (::String char) -> bool
 
-      def delimiter?: (untyped char) -> untyped
+      def delimiter?: (::String? char) -> bool
 
-      def unquoted_string_delimiter?: (untyped char) -> untyped
+      def unquoted_string_delimiter?: (::String? char) -> bool
 
-      def function_name_char_start?: (untyped char) -> untyped
+      def function_name_char_start?: (::String? char) -> bool
 
-      def function_name_char?: (untyped char) -> untyped
+      def function_name_char?: (::String? char) -> bool
 
-      def start_of_value?: (untyped char) -> untyped
+      def start_of_value?: (::String? char) -> bool
 
-      def control_character?: (untyped char) -> untyped
+      def control_character?: (::String? char) -> bool
 
-      def whitespace?: (untyped char) -> untyped
+      def whitespace?: (::String? char) -> bool
 
-      def whitespace_except_newline?: (untyped char) -> untyped
+      def whitespace_except_newline?: (::String? char) -> bool
 
-      def special_whitespace?: (untyped char) -> untyped
+      def special_whitespace?: (::String? char) -> bool
 
-      def quote?: (untyped char) -> untyped
+      def same_line_whitespace?: (::String? char) -> bool
 
-      def double_quote?: (untyped char) -> untyped
+      def whitespace_or_special?: (::String? char) -> bool
 
-      def single_quote?: (untyped char) -> untyped
+      def quote?: (::String? char) -> bool
 
-      def double_quote_like?: (untyped char) -> untyped
+      def double_quote?: (::String? char) -> bool
 
-      def single_quote_like?: (untyped char) -> untyped
+      def single_quote?: (::String? char) -> bool
+
+      def double_quote_like?: (::String? char) -> bool
+
+      def single_quote_like?: (::String? char) -> bool
 
       # Strip last occurrence of text_to_strip from text
-      def strip_last_occurrence: (untyped text, untyped text_to_strip, ?strip_remaining_text: bool) -> untyped
+      def strip_last_occurrence: (::String text, ::String text_to_strip, ?strip_remaining_text: bool) -> ::String
 
-      def insert_before_last_whitespace: (untyped text, untyped text_to_insert) -> untyped
+      def insert_before_last_whitespace: (::String text, ::String text_to_insert) -> ::String
 
       # Parse keywords true, false, null
       # Repair Python keywords True, False, None
       # Repair Ruby keyword nil
-      def parse_keywords: () -> untyped
+      def parse_keywords: () -> bool
 
-      def parse_keyword: (untyped name, untyped value) -> (true | false)
+      def parse_keyword: (::String name, ::String value) -> bool
 
-      def remove_at_index: (untyped text, untyped start, untyped count) -> untyped
+      def remove_at_index: (::String text, ::Integer start, ::Integer count) -> ::String
 
-      def ends_with_comma_or_newline?: (untyped text) -> untyped
+      def ends_with_comma_or_newline?: (::String text) -> bool
     end
   end
 end

data/sig/json/repair.rbs

@@ -1,4 +1,10 @@
 module JSON
+  # Recursive type for any `JSON.parse` result. Mirrors what stdlib's
+  # `JSON.parse` produces (and the JS upstream emits): scalars, arrays,
+  # and objects of the same. Used in place of `untyped` for the
+  # `return_objects: true` and internal `*_parse` paths.
+  type json_value = ::Hash[::String, json_value] | ::Array[json_value] | ::String | ::Integer | ::Float | bool | nil
+
   class JSONRepairError < StandardError
     attr_reader position: ::Integer?
 
@@ -9,13 +15,25 @@ module JSON
     VERSION: ::String
   end
 
+  interface _Readable
+    def read: () -> ::String?
+  end
+
   def self.repair: (::String json, return_objects: false, ?skip_json_loads: bool) -> ::String
-                 | (::String json, return_objects: true, ?skip_json_loads: bool) -> untyped
+                 | (::String json, return_objects: true, ?skip_json_loads: bool) -> json_value
                  | (::String json, ?skip_json_loads: bool) -> ::String
 
+  def self.repair_io: (_Readable io, return_objects: false, ?skip_json_loads: bool) -> ::String
+                    | (_Readable io, return_objects: true, ?skip_json_loads: bool) -> json_value
+                    | (_Readable io, ?skip_json_loads: bool) -> ::String
+
+  def self.repair_file: (::String | ::Pathname path, return_objects: false, ?skip_json_loads: bool) -> ::String
+                      | (::String | ::Pathname path, return_objects: true, ?skip_json_loads: bool) -> json_value
+                      | (::String | ::Pathname path, ?skip_json_loads: bool) -> ::String
+
   private
 
-  def self.tolerant_parse: (::String json) -> untyped
+  def self.tolerant_parse: (::String json) -> json_value
 
-  def self.repaired_parse: (::String json) -> untyped
+  def self.repaired_parse: (::String json) -> json_value
 end

data/sig/json/repairer.rbs

@@ -11,7 +11,7 @@ module JSON
     # `lib/json/repairer.rb`).
     @json: untyped
 
-    @index: Integer
+    @index: ::Integer
 
     @output: ::String
 
@@ -31,25 +31,36 @@ module JSON
 
     private
 
-    def parse_value: () -> untyped
+    def parse_value: () -> bool
 
-    def parse_whitespace: (?skip_newline: bool) -> (true | false)
+    def parse_whitespace: (?skip_newline: bool) -> bool
 
-    def parse_comment: () -> (true | false)
+    def parse_comment: () -> bool
 
     # Find and skip over a Markdown fenced code block
-    def parse_markdown_code_block: (::Array[::String] blocks) -> (true | false)
+    def parse_markdown_code_block: (::Array[::String] blocks) -> bool
 
-    def skip_markdown_code_block: (::Array[::String] blocks) -> (true | false)
+    def skip_markdown_code_block: (::Array[::String] blocks) -> bool
+
+    # Look ahead for a Markdown list marker like "- " or "12. " that
+    # precedes a value; returns the marker's length, or nil when there
+    # is no marker.
+    def markdown_list_marker_length: () -> ::Integer?
+
+    def skip_markdown_list_marker: () -> bool
 
     # Parse an object like '{"key": "value"}'
-    def parse_object: () -> (false | true)
+    def parse_object: () -> bool
 
-    def skip_character: (untyped char) -> (true | false)
+    # Repair an object value with unescaped quotes around a colon,
+    # like {"a": "b": "c"}, by merging it into one string value.
+    def repair_doubled_colon: () -> void
+
+    def skip_character: (::String char) -> bool
 
     # Skip ellipsis like "[1,2,3,...]" or "[1,2,3,...,9]" or "[...,7,8,9]"
     # or a similar construct in objects.
-    def skip_ellipsis: () -> untyped
+    def skip_ellipsis: () -> void
 
     # Parse a string enclosed by double quotes "...". Can contain escaped quotes
     # Repair strings enclosed in single quotes or special quotes
@@ -62,51 +73,59 @@ module JSON
     #   more conservative way, stopping the string at the first next delimiter
     #   and fixing the string by inserting a quote there, or stopping at a
     #   stop index detected in the first iteration.
-    def parse_string: (?stop_at_delimiter: bool, ?stop_at_index: ::Integer) -> (untyped | true | false)
+    def parse_string: (?stop_at_delimiter: bool, ?stop_at_index: ::Integer) -> bool
 
     # Repair an unquoted string by adding quotes around it
     # Repair a MongoDB function call like NumberLong("2")
     # Repair a JSONP function call like callback({...});
-    def parse_unquoted_string: (bool is_key) -> (false | true)
+    def parse_unquoted_string: (bool is_key) -> bool
 
     # Parse a regular expression literal like /foo/ or /foo\/bar/
-    def parse_regex: () -> (false | true)
+    def parse_regex: () -> bool
 
-    def parse_character: (untyped char) -> (true | false)
+    def parse_character: (::String char) -> bool
 
-    def parse_whitespace_and_skip_comments: (?skip_newline: bool) -> untyped
+    def parse_whitespace_and_skip_comments: (?skip_newline: bool) -> bool
 
     # Parse a number like 2.4 or 2.4e6
-    def parse_number: () -> (true | false)
+    def parse_number: () -> bool
 
-    def at_end_of_number?: () -> untyped
+    def at_end_of_number?: () -> bool
 
     # Parse an array like '["item1", "item2", ...]'
-    def parse_array: () -> (true | false)
+    def parse_array: () -> bool
 
-    def prev_non_whitespace_index: (untyped start) -> untyped
+    def prev_non_whitespace_index: (::Integer start) -> ::Integer
 
     # Repair concatenated strings like "hello" + "world", change this into "helloworld"
-    def parse_concatenated_string: () -> untyped
+    def parse_concatenated_string: () -> bool
+
+    def repair_number_ending_with_numeric_symbol: (::Integer start) -> void
 
-    def repair_number_ending_with_numeric_symbol: (untyped start) -> untyped
+    # Repair a number missing its digit before the decimal point, like ".5"
+    # or "-.5", into "0.5" / "-0.5".
+    def repair_leading_dot_number: (::String num) -> ::String
 
     # Parse and repair Newline Delimited JSON (NDJSON):
     # multiple JSON objects separated by a newline character
-    def parse_newline_delimited_json: () -> untyped
+    def parse_newline_delimited_json: () -> void
 
-    def skip_escape_character: () -> untyped
+    def skip_escape_character: () -> bool
 
-    def throw_invalid_character: (untyped char) -> untyped
+    # `bot` (bottom) because these always raise — steep needs this to
+    # treat their call sites as unreachable so methods like `repair`
+    # type-check (the trailing `throw_unexpected_character` must not
+    # contribute `void` to the method's union return type).
+    def throw_invalid_character: (::String char) -> bot
 
-    def throw_unexpected_character: () -> untyped
+    def throw_unexpected_character: () -> bot
 
-    def throw_unexpected_end: () -> untyped
+    def throw_unexpected_end: () -> bot
 
-    def throw_object_key_expected: () -> untyped
+    def throw_object_key_expected: () -> bot
 
-    def throw_colon_expected: () -> untyped
+    def throw_colon_expected: () -> bot
 
-    def throw_invalid_unicode_character: () -> untyped
+    def throw_invalid_unicode_character: () -> bot
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-repair
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Aleksandr Zykov
@@ -9,7 +9,11 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: This is a simple gem that repairs broken JSON strings.
+description: 'Repairs broken JSON: missing quotes and commas, unclosed brackets, trailing
+  commas, unquoted keys, single quotes, comments, Python constants, NDJSON, Markdown
+  code fences and list markers in LLM output, truncated documents, and more. A Ruby
+  port of the jsonrepair JavaScript library — useful whenever JSON from LLMs, APIs,
+  or logs does not strictly follow the standard.'
 email:
 - alexandrz@gmail.com
 executables:
@@ -44,6 +48,8 @@ metadata:
   homepage_uri: https://github.com/sashazykov/json-repair-rb
   source_code_uri: https://github.com/sashazykov/json-repair-rb
   changelog_uri: https://github.com/sashazykov/json-repair-rb/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/json-repair
+  bug_tracker_uri: https://github.com/sashazykov/json-repair-rb/issues
 rdoc_options: []
 require_paths:
 - lib
@@ -60,5 +66,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Repairs broken JSON strings.
+summary: Repair invalid or malformed JSON documents, including LLM output.
 test_files: []