jsonfix-llm 0.1.0__py3-none-any.whl

jsonfix_llm/__init__.py

@@ -0,0 +1,5 @@
+from jsonfix_llm.extract.extract_code import extract_code
+from jsonfix_llm.extract.extract_json import extract_json
+from jsonfix_llm.repair.pipeline import repair_json
+
+__all__ = ["repair_json", "extract_json", "extract_code"]

jsonfix_llm/cli/main.py

@@ -0,0 +1,75 @@
+import sys
+
+import typer
+from typer.core import TyperGroup
+
+from jsonfix_llm import extract_code, repair_json
+
+
+class NaturalOrderGroup(TyperGroup):
+    def parse_args(self, ctx, args):
+        if args and args[0] in self.commands:
+            return super().parse_args(ctx, args)
+        return super().parse_args(ctx, ["repair", *args])
+
+
+app = typer.Typer(cls=NaturalOrderGroup)
+
+
+@app.command()
+def repair(
+    file: str = typer.Argument(None, help="JSON file to repair (stdin if omitted)"),
+    output: str = typer.Option(None, "-o", "--output", help="Write output to file"),
+    stats: bool = typer.Option(False, "--stats", help="Show repair statistics"),
+):
+    if file:
+        with open(file, encoding="utf-8") as f:
+            text = f.read()
+    else:
+        text = sys.stdin.read()
+
+    result = repair_json(text, rich=stats)
+    if stats:
+        typer.echo(result.fixed)
+        typer.echo(f"// Repaired: {result.was_repaired}", err=True)
+        fixes_summary = ", ".join(result.fixes) if result.fixes else "none"
+        typer.echo(f"// Fixes applied: {fixes_summary}", err=True)
+        typer.echo(f"// Errors: {result.error_count}", err=True)
+        if result.errors:
+            for err in result.errors:
+                typer.echo(f"//   - {err}", err=True)
+    else:
+        output_text = result if isinstance(result, str) else result.fixed
+        if output:
+            with open(output, "w", encoding="utf-8") as f:
+                f.write(output_text)
+        else:
+            typer.echo(output_text)
+
+
+@app.command()
+def extract(
+    file: str = typer.Argument(None, help="File to extract from (stdin if omitted)"),
+    language: str = typer.Option("python", "--language", "-l",
+                                  help="Programming language to extract"),
+    output: str = typer.Option(None, "-o", "--output", help="Write output to file"),
+    all_blocks: bool = typer.Option(False, "--all", help="Extract all matching blocks"),
+):
+    if file:
+        with open(file, encoding="utf-8") as f:
+            text = f.read()
+    else:
+        text = sys.stdin.read()
+
+    result = extract_code(text, language=language, all=all_blocks)
+    output_text = "\n---\n".join(result) if isinstance(result, list) else result
+
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            f.write(output_text)
+    else:
+        typer.echo(output_text)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

jsonfix_llm/extract/extract_code.py

@@ -0,0 +1,48 @@
+import re
+
+
+def _extract_fenced(text: str, language: str | None) -> list[str]:
+    if language:
+        lang_pattern = re.escape(language)
+        pattern = rf"```{lang_pattern}\s*\n(.*?)\n```"
+    else:
+        pattern = r"```\w*\s*\n(.*?)\n```"
+    return re.findall(pattern, text, re.DOTALL)
+
+
+def _extract_xml(text: str, tag: str) -> list[str]:
+    pattern = rf"<{tag}>(.*?)</{tag}>"
+    return re.findall(pattern, text, re.DOTALL)
+
+
+def _extract_indented(text: str) -> list[str]:
+    blocks = []
+    current: list[str] = []
+    for line in text.split("\n"):
+        if line.startswith("    ") or line.startswith("\t"):
+            current.append(line.lstrip())
+        elif current:
+            blocks.append("\n".join(current))
+            current = []
+    if current:
+        blocks.append("\n".join(current))
+    return blocks
+
+
+def _extract_inline(text: str) -> list[str]:
+    return re.findall(r"`([^`]+)`", text)
+
+
+def extract_code(text: str, language: str | None = None, all: bool = False) -> str | list[str]:
+    blocks = _extract_fenced(text, language)
+    if not blocks:
+        blocks = _extract_xml(text, "code")
+    if not blocks:
+        blocks = _extract_xml(text, "pre")
+    if not blocks:
+        blocks = _extract_indented(text)
+    if not blocks:
+        blocks = _extract_inline(text)
+    if all:
+        return blocks
+    return blocks[0] if blocks else text

jsonfix_llm/extract/extract_json.py

@@ -0,0 +1,89 @@
+
+
+def extract_json(text: str) -> str:
+    brace_depth = 0
+    bracket_depth = 0
+    in_string = False
+    escape = False
+    json_start = -1
+    json_end = -1
+
+    for i, char in enumerate(text):
+        if escape:
+            escape = False
+            continue
+        if char == "\\":
+            escape = True
+            continue
+        if char == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+
+        if char == "{":
+            if brace_depth == 0 and bracket_depth == 0:
+                json_start = i
+            brace_depth += 1
+        elif char == "}":
+            brace_depth -= 1
+            if brace_depth == 0 and bracket_depth == 0:
+                json_end = i + 1
+                break
+        elif char == "[":
+            if bracket_depth == 0 and brace_depth == 0:
+                json_start = i
+            bracket_depth += 1
+        elif char == "]":
+            bracket_depth -= 1
+            if bracket_depth == 0 and brace_depth == 0:
+                json_end = i + 1
+                break
+
+    if json_start >= 0 and json_end > json_start:
+        return text[json_start:json_end]
+
+    return text
+
+
+def extract_json_all(text: str) -> list[str]:
+    blocks = []
+    in_string = False
+    escape = False
+    brace_depth = 0
+    bracket_depth = 0
+    start = -1
+
+    for i, char in enumerate(text):
+        if escape:
+            escape = False
+            continue
+        if char == "\\":
+            escape = True
+            continue
+        if char == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+
+        if char == "{":
+            if brace_depth == 0 and bracket_depth == 0:
+                start = i
+            brace_depth += 1
+        elif char == "}":
+            brace_depth -= 1
+            if brace_depth == 0 and bracket_depth == 0 and start >= 0:
+                blocks.append(text[start : i + 1])
+                start = -1
+        elif char == "[":
+            if bracket_depth == 0 and brace_depth == 0:
+                start = i
+            bracket_depth += 1
+        elif char == "]":
+            bracket_depth -= 1
+            if bracket_depth == 0 and brace_depth == 0 and start >= 0:
+                blocks.append(text[start : i + 1])
+                start = -1
+
+    return blocks

jsonfix_llm/models.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class RepairResult(BaseModel):
+    fixed: str
+    was_repaired: bool
+    fixes: list[str] = []
+    error_count: int = 0
+    errors: list[str] = []

jsonfix_llm/repair/brackets.py

@@ -0,0 +1,33 @@
+def auto_close_brackets(text: str) -> str:
+    in_string = False
+    escape = False
+    stack = []
+
+    for char in text:
+        if escape:
+            escape = False
+            continue
+        if char == "\\":
+            escape = True
+            continue
+        if char == '"':
+            in_string = not in_string
+            continue
+        if in_string:
+            continue
+
+        if char == "{":
+            stack.append("}")
+        elif char == "[":
+            stack.append("]")
+        elif char == "}":
+            if stack and stack[-1] == "}":
+                stack.pop()
+        elif char == "]":
+            if stack and stack[-1] == "]":
+                stack.pop()
+
+    while stack:
+        text += stack.pop()
+
+    return text

jsonfix_llm/repair/commas.py

@@ -0,0 +1,35 @@
+import re
+
+
+def fix_missing_commas(text: str) -> str:
+    text = re.sub(
+        r'("\s*)\n(\s*)("(?=[^:]*:))',
+        r"\1,\n\2\3",
+        text,
+    )
+    text = re.sub(r"(\})\s*\n(\s*)(\{)", r"\1,\n\2\3", text)
+    text = re.sub(r'(\])\s*\n(\s*)("(?=[^:]*:))', r"\1,\n\2\3", text)
+    text = re.sub(r'("\s*)\n(\s*)(\{)', r"\1,\n\2\3", text)
+    text = re.sub(r"(\})\s*\n(\s*)(\[)", r"\1,\n\2\3", text)
+    text = re.sub(r"(\])\s*\n(\s*)(\{)", r"\1,\n\2\3", text)
+    text = re.sub(r'(\])\s*\n(\s*)(\[)', r"\1,\n\2\3", text)
+    text = re.sub(
+        r"(\d+|true|false|null)\s*\n(\s*)("
+        r'"(?=[^:]*:))',
+        r"\1,\n\2\3",
+        text,
+        flags=re.IGNORECASE,
+    )
+    return text
+
+
+def fix_trailing_commas(text: str) -> str:
+    text = re.sub(r",\s*\}", "}", text)
+    text = re.sub(r",\s*\]", "]", text)
+    return text
+
+
+def fix_commas(text: str) -> str:
+    text = fix_trailing_commas(text)
+    text = fix_missing_commas(text)
+    return text

jsonfix_llm/repair/comments.py

@@ -0,0 +1,50 @@
+import re
+
+
+def _is_inside_string(line: str, pos: int) -> bool:
+    in_double = False
+    in_single = False
+    escape = False
+    for i in range(pos):
+        ch = line[i]
+        if escape:
+            escape = False
+            continue
+        if ch == "\\":
+            escape = True
+            continue
+        if ch == '"' and not in_single:
+            in_double = not in_double
+        elif ch == "'" and not in_double:
+            in_single = not in_single
+    return in_double or in_single
+
+
+def strip_line_comments(text: str) -> str:
+    lines = text.split("\n")
+    result = []
+    for line in lines:
+        comment_pos = -1
+        i = 0
+        while i < len(line):
+            if line[i] == "/" and i + 1 < len(line) and line[i + 1] == "/":
+                if not _is_inside_string(line, i):
+                    comment_pos = i
+                    break
+                i += 2
+            else:
+                i += 1
+        if comment_pos >= 0:
+            line = line[:comment_pos].rstrip()
+        result.append(line)
+    return "\n".join(result)
+
+
+def strip_block_comments(text: str) -> str:
+    return re.sub(r"/\*[\s\S]*?\*/", "", text)
+
+
+def strip_comments(text: str) -> str:
+    text = strip_block_comments(text)
+    text = strip_line_comments(text)
+    return text

jsonfix_llm/repair/control_chars.py

@@ -0,0 +1,29 @@
+def fix_control_chars(text: str) -> str:
+    result = []
+    in_string = False
+    escape = False
+    for char in text:
+        if escape:
+            result.append(char)
+            escape = False
+            continue
+        if char == "\\":
+            result.append(char)
+            escape = True
+            continue
+        if char == '"':
+            in_string = not in_string
+            result.append(char)
+            continue
+        if in_string:
+            if char == "\n":
+                result.append("\\n")
+            elif char == "\t":
+                result.append("\\t")
+            elif char == "\r":
+                result.append("\\r")
+            else:
+                result.append(char)
+        else:
+            result.append(char)
+    return "".join(result)

jsonfix_llm/repair/literals.py

@@ -0,0 +1,45 @@
+MAPPING = {
+    "True": "true",
+    "False": "false",
+    "None": "null",
+    "undefined": "null",
+    "NaN": "null",
+}
+
+
+def fix_python_literals(text: str) -> str:
+    result = []
+    in_string = False
+    escape = False
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if escape:
+            result.append(ch)
+            escape = False
+            i += 1
+            continue
+        if ch == "\\":
+            result.append(ch)
+            escape = True
+            i += 1
+            continue
+        if ch == '"':
+            in_string = not in_string
+            result.append(ch)
+            i += 1
+            continue
+        if in_string:
+            result.append(ch)
+            i += 1
+            continue
+        if ch.isalpha() or ch == "_":
+            start = i
+            while i < len(text) and (text[i].isalnum() or text[i] == "_"):
+                i += 1
+            word = text[start:i]
+            result.append(MAPPING.get(word, word))
+        else:
+            result.append(ch)
+            i += 1
+    return "".join(result)

jsonfix_llm/repair/markdown.py

@@ -0,0 +1,11 @@
+def strip_markdown_fences(text: str) -> str:
+    lines = text.split("\n")
+    result = []
+    in_fence = False
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("```"):
+            in_fence = not in_fence
+            continue
+        result.append(line)
+    return "\n".join(result)

jsonfix_llm/repair/pipeline.py

@@ -0,0 +1,77 @@
+from jsonfix_llm.extract.extract_json import extract_json
+from jsonfix_llm.models import RepairResult
+from jsonfix_llm.repair.brackets import auto_close_brackets
+from jsonfix_llm.repair.commas import fix_commas
+from jsonfix_llm.repair.comments import strip_comments
+from jsonfix_llm.repair.control_chars import fix_control_chars
+from jsonfix_llm.repair.literals import fix_python_literals
+from jsonfix_llm.repair.markdown import strip_markdown_fences
+from jsonfix_llm.repair.quotes import fix_quotes
+from jsonfix_llm.repair.values import fix_values
+from jsonfix_llm.validators.validator import validate_json
+
+
+def repair_json(text: str, rich: bool = False) -> str | RepairResult:
+    fixes = []
+
+    cleaned = strip_markdown_fences(text)
+    if cleaned != text:
+        fixes.append("markdown_fences_stripped")
+
+    if cleaned.startswith("\ufeff"):
+        cleaned = cleaned[1:]
+        fixes.append("bom_stripped")
+
+    no_comments = strip_comments(cleaned)
+    if no_comments != cleaned:
+        fixes.append("comments_stripped")
+    cleaned = no_comments
+
+    extracted = extract_json(cleaned)
+    if extracted != cleaned:
+        fixes.append("json_extracted")
+    cleaned = extracted
+
+    quoted = fix_quotes(cleaned)
+    if quoted != cleaned:
+        fixes.append("quotes_fixed")
+    cleaned = quoted
+
+    literals_fixed = fix_python_literals(cleaned)
+    if literals_fixed != cleaned:
+        fixes.append("literals_fixed")
+    cleaned = literals_fixed
+
+    commas_fixed = fix_commas(cleaned)
+    if commas_fixed != cleaned:
+        fixes.append("commas_fixed")
+    cleaned = commas_fixed
+
+    values_fixed = fix_values(cleaned)
+    if values_fixed != cleaned:
+        fixes.append("values_fixed")
+    cleaned = values_fixed
+
+    escaped = fix_control_chars(cleaned)
+    if escaped != cleaned:
+        fixes.append("control_chars_escaped")
+    cleaned = escaped
+
+    closed = auto_close_brackets(cleaned)
+    if closed != cleaned:
+        fixes.append("brackets_closed")
+    cleaned = closed
+
+    is_valid, errors = validate_json(cleaned)
+    was_repaired = len(fixes) > 0
+
+    if rich:
+        return RepairResult(
+            fixed=cleaned,
+            was_repaired=was_repaired,
+            fixes=fixes,
+            error_count=len(errors),
+            errors=errors,
+        )
+
+    return cleaned

jsonfix_llm/repair/quotes.py

@@ -0,0 +1,95 @@
+def fix_single_quotes(text: str) -> str:
+    result = []
+    in_double = False
+    in_single = False
+    escape = False
+    for char in text:
+        if escape:
+            result.append(char)
+            escape = False
+            continue
+        if char == "\\":
+            result.append(char)
+            escape = True
+            continue
+        if char == '"' and not in_single:
+            in_double = not in_double
+            result.append(char)
+        elif char == "'" and not in_double:
+            in_single = not in_single
+            result.append('"')
+        else:
+            result.append(char)
+    return "".join(result)
+
+
+def _find_identifier(text: str, start: int) -> tuple[int, int, str]:
+    i = start
+    while i < len(text) and text[i] in " \t\n\r":
+        i += 1
+    if i >= len(text) or not (text[i].isalpha() or text[i] == "_"):
+        return start, start, ""
+    ident_start = i
+    while i < len(text) and (text[i].isalnum() or text[i] == "_"):
+        i += 1
+    ident = text[ident_start:i]
+    j = i
+    while j < len(text) and text[j] in " \t\n\r":
+        j += 1
+    if j < len(text) and text[j] == ":":
+        return start, j + 1, ident
+    return start, start, ""
+
+
+def fix_unquoted_keys(text: str) -> str:
+    result = []
+    in_double = False
+    in_single = False
+    escape = False
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if escape:
+            result.append(ch)
+            escape = False
+            i += 1
+            continue
+        if ch == "\\":
+            result.append(ch)
+            escape = True
+            i += 1
+            continue
+        if ch == '"':
+            in_double = not in_double
+            result.append(ch)
+            i += 1
+            continue
+        if ch == "'":
+            in_single = not in_single
+            result.append(ch)
+            i += 1
+            continue
+        if in_double or in_single:
+            result.append(ch)
+            i += 1
+            continue
+        if ch in ("{", ","):
+            result.append(ch)
+            i += 1
+            new_end, after_colon, ident = _find_identifier(text, i)
+            if ident:
+                result.append('"')
+                result.append(ident)
+                result.append('"')
+                result.append(":")
+                i = after_colon
+            continue
+        result.append(ch)
+        i += 1
+    return "".join(result)
+
+
+def fix_quotes(text: str) -> str:
+    text = fix_single_quotes(text)
+    text = fix_unquoted_keys(text)
+    return text

jsonfix_llm/repair/values.py

@@ -0,0 +1,18 @@
+import re
+
+
+def fix_missing_values(text: str) -> str:
+    text = re.sub(r'(")\s*:\s*,', r"\1: null,", text)
+    text = re.sub(r'(")\s*:\s*\}', r"\1: null}", text)
+    return text
+
+
+def fix_missing_colons(text: str) -> str:
+    text = re.sub(r'(")\s+("(?=[^:]*:))', r"\1: \2", text)
+    return text
+
+
+def fix_values(text: str) -> str:
+    text = fix_missing_colons(text)
+    text = fix_missing_values(text)
+    return text

jsonfix_llm/validators/validator.py

@@ -0,0 +1,11 @@
+import json
+
+
+def validate_json(text: str) -> tuple[bool, list[str]]:
+    errors = []
+    try:
+        json.loads(text)
+        return True, errors
+    except json.JSONDecodeError as e:
+        errors.append(f"line {e.lineno}, col {e.colno}: {e.msg}")
+        return False, errors

jsonfix_llm-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: jsonfix-llm
+Version: 0.1.0
+Summary: Repair broken JSON from LLM outputs
+Author-email: shashi kundan <shashikundan0001@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/shashi3070/jsonfix-llm
+Project-URL: Repository, https://github.com/shashi3070/jsonfix-llm
+Project-URL: BugTracker, https://github.com/shashi3070/jsonfix-llm/issues
+Keywords: json,llm,repair,fix,ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Requires-Dist: typer>=0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov>=4; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# jsonfix-llm
+
+Repair broken JSON from LLM outputs. Stop fighting malformed JSON.
+
+## Install
+
+```bash
+pip install jsonfix-llm
+```
+
+## Quick Start
+
+```python
+from jsonfix_llm import repair_json
+
+fixed = repair_json("""{
+  'name': 'shashi'
+  'age': 25
+}""")
+# {"name": "shashi", "age": 25}
+```
+
+## Features
+
+- **Markdown fence stripping** — removes ` ```json ... ``` ` wrappers
+- **Comment stripping** — removes `//` and `/* */` comments
+- **Quote fixing** — single quotes → double quotes, unquoted keys → quoted
+- **Literal fixing** — `True/False/None` → `true/false/null`
+- **Comma fixing** — inserts missing commas, removes trailing commas
+- **Value fixing** — fills missing values, fixes missing colons
+- **Control char escaping** — escapes literal newlines/tabs in strings
+- **Bracket auto-close** — appends missing `}` or `]`, handles truncation
+- **Code extraction** — extracts code from fenced, indented, inline, and XML blocks
+- **CLI tool** — quick repair from the terminal
+
+## API
+
+```python
+from jsonfix_llm import repair_json, extract_code, extract_json
+
+# Simple repair
+fixed = repair_json(text)
+
+# Rich result
+result = repair_json(text, rich=True)
+print(result.fixed)
+print(result.was_repaired)
+print(result.fixes)
+print(result.error_count)
+print(result.errors)
+
+# Extract code (default: first Python block)
+code = extract_code(text)
+# language-specific: extract_code(text, language="python")
+# all blocks: extract_code(text, language="json", all=True)
+
+# Extract JSON blocks
+json_block = extract_json(text)
+json_blocks = extract_json(text, all=True)
+```
+
+## CLI
+
+```bash
+# Repair JSON file
+jsonfix broken.json
+
+# Read from stdin
+echo '{"a":1' | jsonfix
+
+# Write to file
+jsonfix in.json -o fixed.json
+
+# Show repair stats
+jsonfix in.json --stats
+
+# Extract code blocks
+jsonfix extract file.md --language python
+jsonfix extract file.md --language python -o output.py
+jsonfix extract file.md --language json --all
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -v
+```

jsonfix_llm-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+jsonfix_llm/__init__.py,sha256=8y4QbO4r7mhz9fYwggJtgkma05lRfex1Uq2uNjyqSgE,227
+jsonfix_llm/models.py,sha256=WmBb_8MXQu4rc4G5Q8IXXFA6t5qqFQTBZWc0cQJzyqU,180
+jsonfix_llm/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonfix_llm/cli/main.py,sha256=0ugAbLDGws9mzFAR0HIYQap79AVWvG57S4HPGGOHsNs,2446
+jsonfix_llm/extract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonfix_llm/extract/extract_code.py,sha256=AJD2mr161WMQTjXf4UqNxyI_bosb_3ijGOVAqb_7IB0,1385
+jsonfix_llm/extract/extract_json.py,sha256=UoWvlLLT55xf8XJC-lgdsZY00fl-I65JW7gwQT2z3XM,2357
+jsonfix_llm/repair/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonfix_llm/repair/brackets.py,sha256=YOM62wRzlDm_vpObthVj5OQYhTf3YbliGnYnvQX-5t8,755
+jsonfix_llm/repair/commas.py,sha256=58hwa_t9PpvDJ8Q19Ln8_RG2YLkr2Vw3yzm24o1rFD4,969
+jsonfix_llm/repair/comments.py,sha256=rZJ7xX4H8mFhw8xzfJjafhU6ujOB-EdsrKdKx8FH2K8,1293
+jsonfix_llm/repair/control_chars.py,sha256=FjIZkLRIQdq0FwPWO0nQyoLRpK8LKP_-HTtNqFE22zQ,789
+jsonfix_llm/repair/literals.py,sha256=dlA9j_fD1rbDAMwI2CstWogYVAcH5BZjdEMtGTHb__I,1067
+jsonfix_llm/repair/markdown.py,sha256=P5NaXUXhIruLFEaPS_pZ_B3DN4JE3cZJ2a-zlJc3Q_Q,319
+jsonfix_llm/repair/pipeline.py,sha256=OFnPcM4kYSSVhpygv8Huymcf9N-3g_g05nToxYkikZA,2308
+jsonfix_llm/repair/quotes.py,sha256=QJFqsuiMGMv813Sx12cjcofBzuT18Hu0oOUSMQ65BWU,2537
+jsonfix_llm/repair/values.py,sha256=uzyZTJJlJEVG4Jb4RlNd9rrHYhox7JdiNRLhw1xLJaM,422
+jsonfix_llm/validators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonfix_llm/validators/validator.py,sha256=87jFq5K62FYhiJn5YUFmTLkdLIWwANfGjQhOvsTGvL8,281
+jsonfix_llm-0.1.0.dist-info/licenses/LICENSE,sha256=v2spsd7N1pKFFh2G8wGP_45iwe5S0DYiJzG4im8Rupc,1066
+jsonfix_llm-0.1.0.dist-info/METADATA,sha256=hG5rF5ZZiske_dnhtjJ_vmPlWir1sNL1HeiyAhr9Ils,3326
+jsonfix_llm-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+jsonfix_llm-0.1.0.dist-info/entry_points.txt,sha256=t5uti_8doLlMgaGNHT5kUkBpBloNzrK5TTVgTTEE-e4,53
+jsonfix_llm-0.1.0.dist-info/top_level.txt,sha256=Tobbloae5p5SAtCD_4mRmSPERlmul52CQ4ZxHEZXd_s,12
+jsonfix_llm-0.1.0.dist-info/RECORD,,

jsonfix_llm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jsonfix_llm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jsonfix = jsonfix_llm.cli.main:app

jsonfix_llm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jsonfix_llm-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+jsonfix_llm