feat(parsing): single-quote JSON repair + raw bracket span (#28)

[haasonsaas]

Summary

• Robust LLM output parsing with fallback strategies #28 LLM output parsing: when JSON uses single-quoted keys/values (e.g. [{'line': 9, 'issue': 'Bug'}]), convert_single_quoted_json_to_double converts to valid JSON; find_balanced_bracket_span extracts raw [..]/{..} when valid parse fails so repair can run.
• ROADMAP: Robust LLM output parsing with fallback strategies #28 repairs documented; Dynamic context: enclosing function/class boundary detection #25 (dynamic context) added to Shipped (already in codebase: find_enclosing_boundary_line in context).

Test plan

• cargo test parsing::llm_response (includes parse_json_with_single_quotes)
• cargo clippy --all-targets

Made with Cursor

[cursor]

PR Summary

Medium Risk
Moderate risk because it changes LLM response JSON extraction/repair heuristics, which could alter what comments are emitted or incorrectly “repair” malformed text. Scope is limited to parsing with added targeted tests for the new cases.

Overview
Improves structured LLM-output parsing by adding a non-JSON-validating fallback that extracts the first balanced [...]/{...} span when normal JSON discovery fails, so repair can still run.

Extends repair_json_candidates to convert single-quoted JSON-like output into valid JSON via convert_single_quoted_json_to_double, and adds a test covering this case. Updates the roadmap to mark these parsing fallbacks (and dynamic context) as shipped.

^{Written by Cursor Bugbot for commit 0fed671. This will update automatically on new commits. Configure here.}

[sentry]

Bug: The convert_single_quoted_json_to_double function incorrectly handles backslash escape sequences in single-quoted strings, causing it to produce invalid JSON for inputs containing escapes like \n.
_{Severity: HIGH}

Suggested Fix

In the inner loop of convert_single_quoted_json_to_double that processes single-quoted strings, ensure the escape_next flag is reset to false after processing the character that follows a backslash. This should be done in the else block and after handling an escaped single quote if the logic is to continue processing.

Prompt for AI Agent

Review the code at the location below. A potential bug has been identified by an AI
agent.
Verify if this is a real issue. If it is, propose a fix; if not, explain why it's not
valid.

Location: src/parsing/llm_response.rs#L455-L457

Potential issue: The function `convert_single_quoted_json_to_double` incorrectly
processes backslash escape sequences within single-quoted strings. When a backslash is
encountered, an `escape_next` flag is set to true. However, this flag is not reset if
the following character is anything other than a single quote. This causes the flag to
persist across subsequent characters in the string. As a result, when the actual closing
single quote is found, it is incorrectly treated as an escaped character, leading to a
malformed output string that is not valid JSON (e.g., it may be missing a closing
double-quote). This will cause JSON parsing to fail for any LLM response containing
single-quoted strings with common escape sequences like `\n` or `\t`.

_{Did we get this right? 👍 / 👎 to inform future reviews.}

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{Bugbot Autofix is ON. A cloud agent has been kicked off to fix the reported issue.}

[cursor]

Inner loop never resets escape_next for non-quote chars

High Severity

In convert_single_quoted_json_to_double, the inner for loop processing single-quoted string contents sets escape_next = true when it encounters \, but only checks/resets escape_next inside the c == '\'' branch. For any non-quote character following a backslash (e.g. \n, \t, \\), escape_next remains true indefinitely. This causes the actual closing ' to be misidentified as an escaped quote, producing corrupted output or an unclosed string. The outer loop and find_balanced_json both correctly handle this by checking escape_next at the top of the loop — the inner loop needs the same pattern.