release fixes

Author: adwantg

README.md

@@ -257,7 +257,7 @@ pydanticforge generate [OPTIONS]
 
 | Option | Description |
 |--------|-------------|
-| `--input` | JSON file or directory (repeat for multiple). Reads all `.json` files (recursive if directory). |
+| `--input` | JSON file or directory (repeat for multiple). Directory scans include `.json`, `.ndjson`, and `.jsonl` files (recursive). |
 | `--from-state` | Use this state file instead of inferring from input. |
 | `--from-json-schema` | Use this JSON Schema file as input. |
 | `--output` | Output path for generated `models.py`. If omitted, prints to stdout. |
@@ -279,6 +279,7 @@ From a single file or directory:
 
 ```bash
 pydanticforge generate --input ./samples/data.json --output models.py
+pydanticforge generate --input ./samples/events.ndjson --output models.py
 pydanticforge generate --input ./samples/ --output models.py
 ```
 
@@ -298,7 +299,7 @@ pydanticforge generate --from-json-schema schema.json --output models.py
 
 ### `monitor` — Scan directory for schema drift
 
-Scans a directory for `.json` files, infers type from each file’s content, and compares to the expected schema from the state file. Reports drift (type mismatches, missing required fields, new fields). Optionally updates state and regenerates models (autopatch).
+Scans a directory for `.json`, `.ndjson`, and `.jsonl` files, infers type from each file’s content, and compares to the expected schema from the state file. Reports drift (type mismatches, missing required fields, new fields). Optionally updates state and regenerates models (autopatch).
 
 ```bash
 pydanticforge monitor <directory> [OPTIONS]
@@ -348,7 +349,7 @@ Monitor exit codes:
 
 ### `diff` — Semantic diff between two model files
 
-Parses two Python files containing Pydantic `BaseModel` classes and prints a semantic diff (added/removed classes and fields, required/optional and type changes), classified as breaking or non-breaking.
+Parses two Python files containing Pydantic `BaseModel` or `RootModel` classes and prints a semantic diff (added/removed classes and fields, required/optional and type changes), classified as breaking or non-breaking.
 
 ```bash
 pydanticforge diff <old_model.py> <new_model.py> [OPTIONS]
@@ -612,7 +613,7 @@ Use the same `strict_numbers` when calling `join_types` (e.g. in monitor autopat
 ## Input and output formats
 
 - **Stdin (watch / generate):** Newline-delimited JSON (NDJSON). Each line is one JSON value (object or array). If a line is an array, each element is treated as a separate sample.
-- **Files:** `.json` files. Content can be a single JSON value (object or array) or NDJSON; arrays are expanded into one sample per element.
+- **Files:** `.json`, `.ndjson`, and `.jsonl` files. Content can be a single JSON value (object or array) or NDJSON; arrays are expanded into one sample per element.
 - **State file:** JSON file with `schema_version` and `root` (internal type graph). Do not edit by hand; use CLI or `save_schema_state` / `load_schema_state`.
 - **JSON Schema:** Draft 2020-12 document import/export for state interop (`schema`, `generate`, `watch`, `monitor`).
 - **Monitor JSON report:** `monitor --format json` emits machine-readable summary + per-file/per-event severities.
@@ -645,7 +646,7 @@ Quality checks:
 ruff check .
 ruff format --check .
 mypy src
-pytest -q
+python -m pytest -q
 pip-audit
 ```
 

pyproject.toml

@@ -1,4 +1,4 @@
-# Author: Goutam Adwant
+# Author: gadwant
 [build-system]
 requires = ["hatchling>=1.27.0"]
 build-backend = "hatchling.build"

src/pydanticforge/diff/semantic.py

@@ -68,19 +68,43 @@ def _classify_type_change(old: str, new: str) -> str:
     return "changed"
 
 
-def _is_basemodel_subclass(class_node: ast.ClassDef) -> bool:
+def _base_name(base: ast.expr) -> str | None:
+    if isinstance(base, ast.Name):
+        return base.id
+    if isinstance(base, ast.Attribute):
+        return base.attr
+    if isinstance(base, ast.Subscript):
+        return _base_name(base.value)
+    return None
+
+
+def _has_model_base(class_node: ast.ClassDef, base_name: str) -> bool:
+    return any(_base_name(base) == base_name for base in class_node.bases)
+
+
+def _is_pydantic_model_subclass(class_node: ast.ClassDef) -> bool:
+    return _has_model_base(class_node, "BaseModel") or _has_model_base(class_node, "RootModel")
+
+
+def _extract_root_model_annotation(class_node: ast.ClassDef) -> str | None:
     for base in class_node.bases:
-        if isinstance(base, ast.Name) and base.id == "BaseModel":
-            return True
-        if isinstance(base, ast.Attribute) and base.attr == "BaseModel":
-            return True
-    return False
+        if _base_name(base) != "RootModel":
+            continue
+
+        if isinstance(base, ast.Subscript):
+            return _normalize_annotation(ast.unparse(base.slice))
+        return "Any"
+
+    return None
 
 
 def _is_field_required(statement: ast.AnnAssign) -> bool:
     if statement.value is None:
         return True
 
+    if isinstance(statement.value, ast.Constant) and statement.value.value is ...:
+        return True
+
     if isinstance(statement.value, ast.Call):
         fn = statement.value.func
         if isinstance(fn, ast.Name) and fn.id == "Field":
@@ -98,10 +122,15 @@ def parse_pydantic_models(path: Path) -> ModelSchema:
     for node in tree.body:
         if not isinstance(node, ast.ClassDef):
             continue
-        if not _is_basemodel_subclass(node):
+        if not _is_pydantic_model_subclass(node):
             continue
 
         fields: dict[str, ModelField] = {}
+
+        root_annotation = _extract_root_model_annotation(node)
+        if root_annotation is not None:
+            fields["__root__"] = ModelField(annotation=root_annotation, required=True)
+
         for statement in node.body:
             if not isinstance(statement, ast.AnnAssign):
                 continue

src/pydanticforge/io/files.py

@@ -10,6 +10,8 @@
 
 orjson: Any | None = importlib.import_module("orjson") if find_spec("orjson") is not None else None
 
+_JSON_FILE_SUFFIXES = (".json", ".ndjson", ".jsonl")
+
 
 def _loads(raw: bytes | str) -> Any:
     if orjson is not None:
@@ -21,10 +23,39 @@ def _loads(raw: bytes | str) -> Any:
     return json.loads(raw)
 
 
+def _parse_ndjson(raw: bytes) -> list[Any]:
+    text = raw.decode("utf-8")
+    samples: list[Any] = []
+
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        samples.append(_loads(stripped))
+
+    return samples
+
+
 def read_json_file(path: Path) -> Any:
-    return _loads(path.read_bytes())
+    raw = path.read_bytes()
+    try:
+        return _loads(raw)
+    except ValueError as primary_error:
+        try:
+            ndjson_samples = _parse_ndjson(raw)
+        except (UnicodeDecodeError, ValueError):
+            raise primary_error from None
+
+        if not ndjson_samples:
+            raise primary_error from None
+
+        return ndjson_samples
 
 
 def iter_json_files(directory: Path, *, recursive: bool = True) -> Iterable[Path]:
-    pattern = "**/*.json" if recursive else "*.json"
-    yield from sorted(p for p in directory.glob(pattern) if p.is_file())
+    files: set[Path] = set()
+    for suffix in _JSON_FILE_SUFFIXES:
+        pattern = f"**/*{suffix}" if recursive else f"*{suffix}"
+        files.update(path for path in directory.glob(pattern) if path.is_file())
+
+    yield from sorted(files)

src/pydanticforge/monitor/watcher.py

@@ -55,8 +55,9 @@ def monitor_directory_once(
                 expected_root = observed
                 continue
 
-            file_events.extend(detect_drift(expected_root, observed, path="$"))
-            if autopatch and file_events:
+            sample_events = detect_drift(expected_root, observed, path="$")
+            file_events.extend(sample_events)
+            if autopatch and sample_events:
                 expected_root = join_types(
                     expected_root,
                     observed,

tests/integration/test_cli.py

@@ -255,3 +255,59 @@ def test_monitor_breaking_exit_code(tmp_path: Path, capsys: object) -> None:
     assert exit_code == 21
     payload = json.loads(captured.out)
     assert payload["summary"]["breaking_events"] >= 1
+
+
+def test_generate_command_from_ndjson_file(tmp_path: Path) -> None:
+    input_file = tmp_path / "samples.ndjson"
+    input_file.write_text('{"id": 1}\n{"id": 2, "name": "alice"}\n', encoding="utf-8")
+
+    output = tmp_path / "models.py"
+    exit_code = main(["generate", "--input", str(input_file), "--output", str(output)])
+
+    assert exit_code == 0
+    text = output.read_text(encoding="utf-8")
+    assert "class PydanticforgeModel(BaseModel):" in text
+    assert "name: str | None = None" in text
+
+
+def test_monitor_and_status_support_ndjson_files(tmp_path: Path, capsys: object) -> None:
+    state_file = tmp_path / "state.json"
+    _run_with_stdin(
+        ["generate", "--save-state", str(state_file)],
+        '{"id": 1, "name": "baseline"}\n',
+    )
+    capsys.readouterr()
+
+    logs_dir = tmp_path / "logs"
+    logs_dir.mkdir()
+    (logs_dir / "events.ndjson").write_text(
+        '{"id": 2, "name": "ok"}\n{"id": "bad", "name": "oops"}\n',
+        encoding="utf-8",
+    )
+
+    monitor_exit = main(
+        [
+            "monitor",
+            str(logs_dir),
+            "--state",
+            str(state_file),
+            "--format",
+            "json",
+            "--fail-on",
+            "breaking",
+        ]
+    )
+    monitor_output = capsys.readouterr()
+
+    assert monitor_exit == 21
+    monitor_payload = json.loads(monitor_output.out)
+    assert monitor_payload["summary"]["files_scanned"] == 1
+    assert monitor_payload["summary"]["breaking_events"] >= 1
+
+    status_exit = main(["status", str(logs_dir), "--state", str(state_file), "--format", "json"])
+    status_output = capsys.readouterr()
+
+    assert status_exit == 0
+    status_payload = json.loads(status_output.out)
+    assert status_payload["drift"]["summary"]["files_scanned"] == 1
+    assert status_payload["drift"]["summary"]["breaking_events"] >= 1

tests/unit/test_diff.py

@@ -55,3 +55,41 @@ def test_semantic_diff_classifies_breaking_and_non_breaking(tmp_path: Path) -> N
         and "optional" in entry.message
         for entry in entries
     )
+
+
+def test_semantic_diff_detects_root_model_type_change(tmp_path: Path) -> None:
+    old_file = tmp_path / "old_root.py"
+    new_file = tmp_path / "new_root.py"
+
+    old_file.write_text(
+        "\n".join(
+            [
+                "from pydantic import RootModel",
+                "",
+                "class Payload(RootModel[int]):",
+                "    pass",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    new_file.write_text(
+        "\n".join(
+            [
+                "from pydantic import RootModel",
+                "",
+                "class Payload(RootModel[str]):",
+                "    pass",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    entries = diff_models(old_file, new_file)
+
+    assert any(
+        entry.field_name == "__root__"
+        and entry.severity == "breaking"
+        and "Type changed" in entry.message
+        for entry in entries
+    )

tests/unit/test_io_files.py

@@ -0,0 +1,53 @@
+# Author: gadwant
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from pydanticforge.io.files import iter_json_files, read_json_file
+
+
+def test_read_json_file_supports_standard_json(tmp_path: Path) -> None:
+    path = tmp_path / "sample.json"
+    path.write_text('{"id": 1, "name": "alice"}', encoding="utf-8")
+
+    payload = read_json_file(path)
+
+    assert payload == {"id": 1, "name": "alice"}
+
+
+def test_read_json_file_supports_ndjson(tmp_path: Path) -> None:
+    path = tmp_path / "sample.ndjson"
+    path.write_text('{"id": 1}\n{"id": 2, "name": "alice"}\n', encoding="utf-8")
+
+    payload = read_json_file(path)
+
+    assert isinstance(payload, list)
+    assert payload[0] == {"id": 1}
+    assert payload[1] == {"id": 2, "name": "alice"}
+
+
+def test_read_json_file_preserves_parse_error_for_invalid_json(tmp_path: Path) -> None:
+    path = tmp_path / "broken.json"
+    path.write_text('{"id":\n 1,\n', encoding="utf-8")
+
+    with pytest.raises(ValueError):
+        read_json_file(path)
+
+
+def test_iter_json_files_includes_json_ndjson_and_jsonl(tmp_path: Path) -> None:
+    (tmp_path / "a.json").write_text("{}", encoding="utf-8")
+    (tmp_path / "b.ndjson").write_text("{}\n", encoding="utf-8")
+    (tmp_path / "c.jsonl").write_text("{}\n", encoding="utf-8")
+    (tmp_path / "ignored.txt").write_text("{}", encoding="utf-8")
+
+    nested = tmp_path / "nested"
+    nested.mkdir()
+    (nested / "d.json").write_text("{}", encoding="utf-8")
+
+    recursive_files = list(iter_json_files(tmp_path, recursive=True))
+    non_recursive_files = list(iter_json_files(tmp_path, recursive=False))
+
+    assert [path.name for path in recursive_files] == ["a.json", "b.ndjson", "c.jsonl", "d.json"]
+    assert [path.name for path in non_recursive_files] == ["a.json", "b.ndjson", "c.jsonl"]