jsonfix-llm 0.1.0__tar.gz

jsonfix_llm-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,88 @@
+# 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/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsonfix-llm"
+version = "0.1.0"
+description = "Repair broken JSON from LLM outputs"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "shashi kundan", email = "shashikundan0001@gmail.com" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing :: General",
+]
+keywords = ["json", "llm", "repair", "fix", "ai"]
+
+dependencies = [
+    "pydantic>=2.0",
+    "typer>=0.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/shashi3070/jsonfix-llm"
+Repository = "https://github.com/shashi3070/jsonfix-llm"
+BugTracker = "https://github.com/shashi3070/jsonfix-llm/issues"
+
+[project.scripts]
+jsonfix = "jsonfix_llm.cli.main:app"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7",
+    "pytest-cov>=4",
+    "ruff>=0.1",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+
+[tool.coverage.run]
+source = ["src/jsonfix_llm"]

jsonfix_llm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsonfix_llm-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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)