diffprep 0.1.0a1__py3-none-any.whl

diffprep/__init__.py

@@ -0,0 +1,4 @@
+import logging
+
+logger = logging.getLogger(__name__)
+logger.debug("Logging is ready")

diffprep/cli/app.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import typer
+
+from diffprep.cli.commands import init as init_module
+from diffprep.cli.commands.json import json_command
+from diffprep.cli.commands.xml import xml_command
+
+app = typer.Typer(help="Command-line JSON and XML diff preprocessor.")
+
+app.command("json")(json_command)
+app.command("xml")(xml_command)
+app.add_typer(init_module.app, name="init")
+
+
+if __name__ == "__main__":
+    app()

diffprep/cli/commands/_normalize.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from diffprep.cli.io import write_stdout_bytes
+from diffprep.cli.prompting import build_llm_prompt, build_prompt_context
+from diffprep.core import Settings
+from diffprep.processors import get_processor
+
+
+def read_input_bytes(path: Path) -> bytes:
+    try:
+        return path.read_bytes()
+    except OSError as exc:
+        raise typer.BadParameter(f"Could not read input file: {path}") from exc
+
+
+def run_normalizer(settings: Settings, path: Path) -> None:
+    if not settings.cli_options:
+        return
+    data = read_input_bytes(path)
+
+    processor = get_processor(settings)
+    out = processor(data, settings)
+
+    if settings.cli_options.question:
+        context = build_prompt_context(
+            question=settings.cli_options.question,
+            input_type=settings.cli_options.input_type,
+            original_input=data,
+            normalized_output=out,
+            settings=settings,
+        )
+        prompt = build_llm_prompt(context)
+        write_stdout_bytes(prompt.encode("utf-8"))
+        return
+
+    write_stdout_bytes(out)

diffprep/cli/commands/init.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final, Literal
+
+import typer
+
+TOOL_NAME: Final[str] = "diffprep"
+BEGIN_MARKER: Final[str] = "# BEGIN diffprep"
+END_MARKER: Final[str] = "# END diffprep"
+
+Status = Literal["created", "updated", "unchanged"]
+
+app = typer.Typer()
+
+
+@dataclass(frozen=True, slots=True)
+class DiffDriver:
+    pattern: str
+    command_name: str
+
+
+DEFAULT_DRIVERS: Final[tuple[DiffDriver, ...]] = (
+    DiffDriver("*.json", "json"),
+    DiffDriver("*.xml", "xml"),
+)
+
+
+def render_gitattributes() -> str:
+    lines = [BEGIN_MARKER]
+    lines.extend(
+        f"{driver.pattern} diff={driver.command_name}" for driver in DEFAULT_DRIVERS
+    )
+    lines.append(END_MARKER)
+    return "\n".join(lines) + "\n"
+
+
+def render_gitconfig_repo() -> str:
+    lines = [BEGIN_MARKER]
+
+    for driver in DEFAULT_DRIVERS:
+        lines.extend(
+            (
+                f'[diff "{driver.command_name}"]',
+                f"    textconv = {TOOL_NAME} {driver.command_name}",
+                "",
+            )
+        )
+
+    if lines[-1] == "":
+        lines.pop()
+
+    lines.append(END_MARKER)
+    return "\n".join(lines) + "\n"
+
+
+def render_unix_wrapper() -> str:
+    return """#!/usr/bin/env sh
+set -eu
+
+repo_root="$(git rev-parse --show-toplevel)"
+git -c include.path="$repo_root/.gitconfig.repo" diff "$@"
+"""
+
+
+def replace_or_append_managed_block(existing: str, managed_block: str) -> str:
+    begin_index = existing.find(BEGIN_MARKER)
+    end_index = existing.find(END_MARKER)
+
+    if begin_index != -1 and end_index != -1 and end_index > begin_index:
+        before = existing[:begin_index].rstrip()
+        after = existing[end_index + len(END_MARKER) :].lstrip()
+
+        parts: list[str] = []
+        if before:
+            parts.append(before)
+        parts.append(managed_block.rstrip())
+        if after:
+            parts.append(after)
+        return "\n\n".join(parts) + "\n"
+
+    existing_clean = existing.rstrip()
+    if not existing_clean:
+        return managed_block
+
+    return f"{existing_clean}\n\n{managed_block}"
+
+
+def write_text_file(path: Path, content: str) -> Status:
+    previous = path.read_text(encoding="utf-8") if path.exists() else None
+    if previous == content:
+        return "unchanged"
+
+    path.write_text(content, encoding="utf-8")
+    return "created" if previous is None else "updated"
+
+
+def write_managed_block_file(path: Path, managed_block: str) -> Status:
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    new_content = replace_or_append_managed_block(existing, managed_block)
+
+    if existing == new_content:
+        return "unchanged"
+
+    path.write_text(new_content, encoding="utf-8")
+    return "created" if not existing else "updated"
+
+
+def make_executable(path: Path) -> None:
+    path.chmod(path.stat().st_mode | 0o111)
+
+
+def run_init() -> None:
+    gitattributes_path = Path(".gitattributes")
+    gitconfig_repo_path = Path(".gitconfig.repo")
+    wrapper_path = Path(TOOL_NAME)
+
+    gitattributes_status = write_managed_block_file(
+        gitattributes_path,
+        render_gitattributes(),
+    )
+    gitconfig_status = write_text_file(gitconfig_repo_path, render_gitconfig_repo())
+    wrapper_status = write_text_file(wrapper_path, render_unix_wrapper())
+    make_executable(wrapper_path)
+
+    typer.echo(f"{gitattributes_status:9} {gitattributes_path.name}")
+    typer.echo(f"{gitconfig_status:9} {gitconfig_repo_path.name}")
+    typer.echo(f"{wrapper_status:9} {wrapper_path.name}")
+    typer.echo()
+    typer.echo("Run:")
+    typer.echo(f"  ./{TOOL_NAME}")
+
+
+@app.callback(invoke_without_command=True)
+def main() -> None:
+    run_init()
+
+
+if __name__ == "__main__":
+    app()

diffprep/cli/commands/json.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from diffprep.cli.commands._normalize import run_normalizer
+from diffprep.cli.models import JsonCliOptions
+from diffprep.core import init_settings
+from diffprep.types import InputType
+
+logger = logging.getLogger(__name__)
+
+
+def json_command(
+    path: Annotated[Path, typer.Argument(exists=True, readable=True)],
+    question: Annotated[str | None, typer.Option("--question", "-q")] = None,
+    drop_keys: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--drop-key",
+            "-d",
+            help="Remove one or more JSON keys before normalization.",
+        ),
+    ] = None,
+) -> None:
+    cli_options = JsonCliOptions(
+        input_type=InputType.JSON,
+        question=question,
+        drop_keys=set(drop_keys or ()),
+    )
+    settings = init_settings(cli_options)
+    logging.debug(settings)
+
+    run_normalizer(settings, path)

diffprep/cli/commands/xml.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from diffprep.cli.commands._normalize import run_normalizer
+from diffprep.cli.models import XmlCliOptions
+from diffprep.core import init_settings
+from diffprep.types import InputType
+
+
+def xml_command(
+    path: Annotated[Path, typer.Argument(exists=True, readable=True)],
+    question: Annotated[str | None, typer.Option("--question", "-q")] = None,
+) -> None:
+    cli_options = XmlCliOptions(
+        input_type=InputType.XML,
+        question=question,
+    )
+    settings = init_settings(cli_options)
+
+    run_normalizer(settings, path)

diffprep/cli/completion.py

@@ -0,0 +1,36 @@
+from collections.abc import Callable
+from enum import StrEnum
+from typing import Annotated, get_args, get_origin
+
+from pydantic import BaseModel
+
+
+def enum_values_for_field(
+    settings_cls: type[BaseModel],
+    field_name: str,
+) -> list[str]:
+    annotation = settings_cls.model_fields[field_name].annotation
+    origin = get_origin(annotation)
+    if origin is Annotated:
+        annotation = get_args(annotation)[0]
+    if isinstance(annotation, type) and issubclass(annotation, StrEnum):
+        return [member.value for member in annotation]
+    return []
+
+
+def description_for_field(
+    settings_cls: type[BaseModel],
+    field_name: str,
+) -> str:
+    field = settings_cls.model_fields[field_name]
+    return field.description or ""
+
+
+def enum_field_completion(
+    settings_cls: type[BaseModel],
+    field_name: str,
+) -> Callable[[str], list[str]]:
+    values = enum_values_for_field(settings_cls, field_name)
+    return lambda incomplete: [
+        value for value in values if value.startswith(incomplete)
+    ]

diffprep/cli/io.py

@@ -0,0 +1,12 @@
+import sys
+
+
+def read_stdin_bytes() -> bytes:
+    data = sys.stdin.buffer.read()
+    if not data:
+        raise ValueError("No input received on stdin.")
+    return data
+
+
+def write_stdout_bytes(data: bytes) -> None:
+    sys.stdout.buffer.write(data)

diffprep/cli/models.py

@@ -0,0 +1,61 @@
+from typing import Literal, override
+
+from pydantic import Field
+
+from diffprep.core import JsonSettings, Settings, XmlSettings
+from diffprep.core.configs import CliOptions
+from diffprep.types import InputType
+
+
+class JsonCliOptions(CliOptions, JsonSettings):
+    input_type: Literal[InputType.JSON] = InputType.JSON
+
+    drop_keys: set[str] = Field(
+        default_factory=set,
+        description="JSON object keys to remove recursively before output.",
+    )
+
+    def to_settings(self) -> JsonSettings:
+        return JsonSettings(
+            drop_keys=self.drop_keys,
+            indent=None if self.style == "compact" else self.indent,
+            sort_keys=self.sort_keys,
+            ensure_ascii=self.ensure_ascii,
+            style=self.style,
+        )
+
+    @override
+    def apply_to(self, settings: Settings) -> Settings:
+        json_update = self.to_settings().model_dump(exclude_unset=True)
+
+        return settings.model_copy(
+            update={
+                "json_settings": settings.json_settings.model_copy(update=json_update),
+            }
+        )
+
+
+class XmlCliOptions(CliOptions, XmlSettings):
+    input_type: Literal[InputType.XML] = InputType.XML
+
+    drop_attrs: set[str] = Field(
+        default_factory=set,
+        description="XML attributes to remove recursively before output.",
+    )
+    drop_tags: set[str] = Field(
+        default_factory=set,
+        description="XML tags to remove recursively before output.",
+    )
+
+    def to_settings(self) -> XmlSettings:
+        return XmlSettings()
+
+    @override
+    def apply_to(self, settings: Settings) -> Settings:
+        update = self.to_settings().model_dump(exclude_unset=True)
+
+        return settings.model_copy(
+            update={
+                "json_settings": settings.json_settings.model_copy(update=update),
+            }
+        )

diffprep/cli/prompting.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from diffprep.core.configs import Settings
+from diffprep.types import InputType
+
+DEFAULT_MAX_PROMPT_CHARS = 4_000
+
+
+def render_settings_help(settings: BaseModel, prefix: str = "") -> str:
+    lines: list[str] = []
+
+    for name, field in settings.model_fields.items():
+        value = getattr(settings, name)
+        path = f"{prefix}.{name}" if prefix else name
+
+        if isinstance(value, BaseModel):
+            lines.append(render_settings_help(value, path))
+        else:
+            env = f"DIFFPREP_{path.replace('.', '__')}"
+            desc = field.description or ""
+            lines.append(f"{path} = {value!r}  ({env})  # {desc}")
+
+    return "\n".join(lines)
+
+
+class PromptContext(BaseModel):
+    """Structured context passed to the LLM prompt renderer."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    question: str = Field(min_length=1)
+    input_type: InputType
+    original_input: str
+    normalized_output: str
+    settings: Settings
+
+    @property
+    def current_command(self) -> str:
+        """CLI command that reproduces the current invocation."""
+        return f"diffprep {self.settings.cli_options}"
+
+
+def decode_bytes(data: bytes, /) -> str:
+    """Decode bytes as UTF-8, replacing invalid sequences."""
+    return data.decode("utf-8", errors="replace")
+
+
+def truncate_text(text: str, /, *, max_chars: int = DEFAULT_MAX_PROMPT_CHARS) -> str:
+    """Truncate text and append a notice if the text was shortened."""
+    if len(text) <= max_chars:
+        return text
+
+    remaining = len(text) - max_chars
+    return (
+        f"{text[:max_chars]}\n\n"
+        f"[truncated: showing first {max_chars} of {len(text)} characters; "
+        f"{remaining} omitted]"
+    )
+
+
+def build_prompt_context(
+    *,
+    question: str,
+    input_type: InputType,
+    original_input: bytes,
+    normalized_output: bytes,
+    settings: Settings,
+    max_chars: int = DEFAULT_MAX_PROMPT_CHARS,
+) -> PromptContext:
+    """Create the structured context used to generate the LLM prompt."""
+
+    cleaned_question = question.strip()
+
+    return PromptContext(
+        question=cleaned_question,
+        input_type=input_type,
+        original_input=truncate_text(decode_bytes(original_input), max_chars=max_chars),
+        normalized_output=truncate_text(
+            decode_bytes(normalized_output),
+            max_chars=max_chars,
+        ),
+        settings=settings,
+    )
+
+
+def build_llm_prompt(context: PromptContext) -> str:
+    """Render the final LLM prompt string."""
+
+    settings_text = context.settings.model_dump_json(indent=2, exclude_none=True)
+    settings_help = render_settings_help(context.settings)
+
+    return f"""
+User question:
+{context.question}
+
+--- PROMPT START ---
+
+You are helping a user of the CLI tool `diffprep`.
+
+Tool purpose:
+`diffprep` preprocesses structured input such as JSON or XML so the output is more stable and useful for diffs.
+
+User question:
+{context.question}
+
+Current command:
+{context.current_command}
+
+Settings (current values and env overrides):
+{settings_help}
+
+Input type:
+{context.input_type.value}
+
+Resolved settings:
+{settings_text}
+
+Original input:
+{context.original_input}
+
+Current output:
+{context.normalized_output}
+
+Please answer in a practical way.
+Include:
+1. what is likely missing or incorrect
+2. the exact command, config, or environment variable change needed
+3. a minimal working example
+4. any common mistakes relevant to this case
+
+--- PROMPT END ---
+"""

diffprep/core/__init__.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import logging
+
+from diffprep.core.logger import setup_logging
+
+from .configs import (
+    CliOptions,
+    JsonSettings,
+    NormalizeSettings,
+    Settings,
+    XmlSettings,
+)
+
+_CURRENT_SETTINGS: Settings | None = None
+
+
+def init_settings(cli_options: CliOptions) -> Settings:
+    global _CURRENT_SETTINGS
+
+    settings = Settings(cli_options=cli_options)
+
+    if cli_options is not None:
+        settings = cli_options.apply_to(settings)
+
+    setup_logging(settings.logger_settings)
+    logging.debug("Settings initialized: \n%s\n", settings.model_dump_json(indent=4))
+
+    _CURRENT_SETTINGS = settings
+    return settings
+
+
+def get_settings() -> Settings:
+    if _CURRENT_SETTINGS is None:
+        raise RuntimeError("Settings have not been initialized.")
+    return _CURRENT_SETTINGS
+
+
+__all__ = [
+    "JsonSettings",
+    "NormalizeSettings",
+    "Settings",
+    "XmlSettings",
+    "get_settings",
+    "init_settings",
+]

diffprep/core/configs.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import ClassVar, Literal, override
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    PyprojectTomlConfigSettingsSource,
+    SettingsConfigDict,
+)
+
+from diffprep.types import InputType
+
+logger = logging.getLogger(__name__)
+
+
+class CliOptions(BaseModel, ABC):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    input_type: InputType
+    question: str | None = None
+
+    @abstractmethod
+    def apply_to(self, settings: Settings) -> Settings:
+        """Return a new Settings object with these CLI overrides applied."""
+        raise NotImplementedError
+
+
+class LoggerSettings(BaseModel):
+    level: Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"] = Field(
+        default="INFO",
+        description="Logging level.",
+    )
+    fmt: str = Field(
+        default="%(filename)-16s:%(lineno)1d  %(message)s",
+        description="Logging format string.",
+    )
+    disable_existing_loggers: bool = Field(
+        default=False,
+        description="Disable pre-existing loggers when configuring logging.",
+    )
+
+
+class NormalizeSettings(BaseModel):
+    trailing_newline: bool = Field(
+        default=True,
+        description="Ensure normalized output ends with a trailing newline.",
+    )
+
+
+class JsonSettings(BaseModel):
+    drop_keys: set[str] = Field(
+        default_factory=set,
+        description="JSON object keys to remove recursively before output.",
+    )
+    indent: int | str | None = Field(
+        default=4,
+        description="Indentation used for pretty JSON output.",
+    )
+    sort_keys: bool = Field(
+        default=True,
+        description="Sort JSON object keys for stable output.",
+    )
+    ensure_ascii: bool = Field(
+        default=False,
+        description="Escape non-ASCII characters in JSON output.",
+    )
+    style: Literal["pretty", "compact"] = Field(
+        default="pretty",
+        description="JSON output style.",
+    )
+
+
+class XmlSettings(BaseModel):
+    drop_tags: set[str] = Field(
+        default_factory=set,
+        description="XML tags to remove recursively before output.",
+    )
+    drop_attrs: set[str] = Field(
+        default_factory=set,
+        description="XML attributes to remove from all elements.",
+    )
+    indent: int = Field(
+        default=4,
+        ge=0,
+        description="Indentation used for pretty XML output.",
+    )
+    pretty: bool = Field(
+        default=True,
+        description="Pretty-print XML output.",
+    )
+    declaration: bool = Field(
+        default=False,
+        description="Include XML declaration in serialized output.",
+    )
+    sort_attrs: bool = Field(
+        default=True,
+        description="Sort XML attributes for stable output.",
+    )
+    strip_text: bool = Field(
+        default=True,
+        description="Strip surrounding whitespace from XML text nodes where applicable.",
+    )
+
+
+class Settings(BaseSettings):
+    model_config: ClassVar[SettingsConfigDict] = SettingsConfigDict(
+        extra="ignore",
+        validate_assignment=True,
+        pyproject_toml_table_header=("tool", "diffprep"),
+        pyproject_toml_depth=3,
+        env_prefix="DIFFPREP_",
+        env_nested_delimiter="__",
+    )
+
+    normalize: NormalizeSettings = Field(default_factory=NormalizeSettings)
+    json_settings: JsonSettings = Field(default_factory=JsonSettings)
+    xml_settings: XmlSettings = Field(default_factory=XmlSettings)
+    logger_settings: LoggerSettings = Field(default_factory=LoggerSettings)
+    cli_options: CliOptions
+
+    @classmethod
+    @override
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        pyproject_settings = PyprojectTomlConfigSettingsSource(settings_cls)
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            pyproject_settings,
+            file_secret_settings,
+        )

diffprep/core/logger.py

@@ -0,0 +1,32 @@
+import logging
+import logging.config
+
+from diffprep.core.configs import LoggerSettings
+
+logger = logging.getLogger(__name__)
+
+
+def build_logging_config(settings: LoggerSettings) -> dict[str, object]:
+    return {
+        "version": 1,
+        "disable_existing_loggers": settings.disable_existing_loggers,
+        "formatters": {
+            "default": {
+                "format": settings.fmt,
+            }
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "formatter": "default",
+            }
+        },
+        "root": {
+            "handlers": ["console"],
+            "level": settings.level,
+        },
+    }
+
+
+def setup_logging(settings: LoggerSettings) -> None:
+    logging.config.dictConfig(build_logging_config(settings))

diffprep/processors/__init__.py

@@ -0,0 +1,33 @@
+import importlib
+import logging
+import pkgutil
+
+from ._registry import (
+    Processor,
+    get_processor,
+    register_processor,
+    validate_registered_processors,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _load_processors() -> None:
+    modules = [
+        mod.name
+        for mod in pkgutil.iter_modules(__path__)
+        if not mod.name.startswith("_")
+    ]
+    logger.debug("Discovered processor modules: %s", modules)
+
+    for name in modules:
+        module_name = f"{__name__}.{name}"
+        logger.debug("Loading processor module: %s", module_name)
+        importlib.import_module(module_name)
+
+
+_load_processors()
+logger.debug("Validating registered processors")
+validate_registered_processors()
+
+__all__ = ["Processor", "get_processor", "register_processor"]

diffprep/processors/_registry.py

@@ -0,0 +1,56 @@
+from collections.abc import Callable, Mapping
+from types import MappingProxyType
+
+from diffprep.core import Settings
+from diffprep.processors._types import (
+    DuplicateProcessorError,
+    Processor,
+    UnknownProcessorError,
+)
+from diffprep.types import InputType
+
+# from diffprep.cli.models import NormalizeOptions
+
+_PROCESSORS: dict[InputType, Processor] = {}
+
+
+def register_processor(input_type: InputType) -> Callable[[Processor], Processor]:
+    def decorator(processor: Processor) -> Processor:
+        if input_type in _PROCESSORS:
+            raise DuplicateProcessorError(
+                f"Processor already registered for {input_type.value!r}"
+            )
+        _PROCESSORS[input_type] = processor
+        return processor
+
+    return decorator
+
+
+def get_processor(options: Settings, /) -> Processor:
+    processor = _PROCESSORS.get(options.cli_options.input_type)
+    if processor is None:
+        available = ", ".join(
+            item.value for item in sorted(_PROCESSORS, key=lambda t: t.value)
+        )
+        raise UnknownProcessorError(
+            f"Unsupported input type {options.cli_options.input_type.value!r}. "
+            f"Available: {available or '<none>'}"
+        )
+    return processor
+
+
+def list_processors() -> tuple[InputType, ...]:
+    return tuple(sorted(_PROCESSORS, key=lambda t: t.value))
+
+
+def processor_mapping() -> Mapping[InputType, Processor]:
+    return MappingProxyType(_PROCESSORS)
+
+
+def validate_registered_processors() -> None:
+    missing = set(InputType) - _PROCESSORS.keys()
+    if missing:
+        missing_names = ", ".join(
+            item.value for item in sorted(missing, key=lambda t: t.value)
+        )
+        raise RuntimeError(f"Missing processor registrations: {missing_names}")

diffprep/processors/_types.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from diffprep.core import Settings
+
+type Processor = Callable[[bytes, Settings], bytes]
+# type Processor = Callable[[bytes], bytes]
+
+
+class ProcessorRegistryError(Exception):
+    """Base error for processor registry problems."""
+
+
+class DuplicateProcessorError(ProcessorRegistryError):
+    """Raised when a processor is registered twice for the same input type."""
+
+
+class UnknownProcessorError(ProcessorRegistryError):
+    """Raised when no processor exists for the requested input type."""

diffprep/processors/json.py

@@ -0,0 +1,66 @@
+import json
+import logging
+
+from diffprep.core import Settings
+from diffprep.core.configs import JsonSettings, NormalizeSettings
+from diffprep.processors import register_processor
+from diffprep.types import InputType, JSONValue
+
+logger = logging.getLogger(__name__)
+
+
+def _decode_json(data: bytes) -> JSONValue:
+    try:
+        return json.loads(data)
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ValueError("Invalid JSON input") from exc
+
+
+def _scrub_json(value: JSONValue, drop_keys: set[str]) -> JSONValue:
+    if isinstance(value, dict):
+        return {
+            key: _scrub_json(child, drop_keys)
+            for key, child in value.items()
+            if key not in drop_keys
+        }
+
+    if isinstance(value, list):
+        return [_scrub_json(item, drop_keys) for item in value]
+
+    return value
+
+
+def _normalize_json(
+    cleaned: JSONValue,
+    *,
+    json_settings: JsonSettings,
+    normalize_settings: NormalizeSettings,
+) -> bytes:
+    separators = (",", ":") if json_settings.style == "compact" else None
+
+    normalized = json.dumps(
+        cleaned,
+        sort_keys=json_settings.sort_keys,
+        separators=separators,
+        ensure_ascii=json_settings.ensure_ascii,
+        indent=json_settings.indent,
+    )
+
+    if normalize_settings.trailing_newline:
+        normalized += "\n"
+
+    return normalized.encode("utf-8")
+
+
+@register_processor(InputType.JSON)
+def process_json(data: bytes, settings: Settings) -> bytes:
+    logging.debug(settings)
+
+    parsed = _decode_json(data)
+    cleaned = _scrub_json(parsed, settings.json_settings.drop_keys)
+
+    return _normalize_json(
+        cleaned,
+        json_settings=settings.json_settings,
+        normalize_settings=settings.normalize,
+    )

diffprep/processors/xml.py

@@ -0,0 +1,15 @@
+import logging
+
+from diffprep.core import Settings
+from diffprep.processors import register_processor
+from diffprep.types import InputType
+
+logger = logging.getLogger(__name__)
+
+
+@register_processor(input_type=InputType.XML)
+def process_xml(data: bytes, settings: Settings) -> bytes:
+    logger.debug(settings)
+
+    out: bytes = data
+    return out

diffprep/types.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+type JSONValue = (
+    dict[str, JSONValue] | list[JSONValue] | str | int | float | bool | None
+)
+
+
+class InputType(StrEnum):
+    JSON = "json"
+    XML = "xml"

diffprep-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.3
+Name: diffprep
+Version: 0.1.0a1
+Summary: Command-line JSON and XML diff preprocessor.
+Author: Dominik Ocsofszki
+Author-email: Dominik Ocsofszki <dominikocsofszki@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2026 Dominik Ocsofszki
+         
+         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.
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: pydantic-settings>=2.13.1
+Requires-Dist: typer>=0.24.1
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# CLI
+
+Command-line JSON and XML diff preprocessor.
+
+**Usage**:
+
+```console
+$ [OPTIONS] COMMAND [ARGS]...
+```
+
+**Options**:
+
+* `--install-completion`: Install completion for the current shell.
+* `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
+* `--help`: Show this message and exit.
+
+**Commands**:
+
+* `json`
+* `xml`
+* `init`
+
+## `json`
+
+**Usage**:
+
+```console
+$ json [OPTIONS] PATH
+```
+
+**Arguments**:
+
+* `PATH`: [required]
+
+**Options**:
+
+* `-q, --question TEXT`
+* `-d, --drop-key TEXT`: Remove one or more JSON keys before normalization.
+* `--help`: Show this message and exit.
+
+## `xml`
+
+**Usage**:
+
+```console
+$ xml [OPTIONS] PATH
+```
+
+**Arguments**:
+
+* `PATH`: [required]
+
+**Options**:
+
+* `-q, --question TEXT`
+* `--help`: Show this message and exit.
+
+## `init`
+
+**Usage**:
+
+```console
+$ init [OPTIONS] COMMAND [ARGS]...
+```
+
+**Options**:
+
+* `--help`: Show this message and exit.
+

diffprep-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,23 @@
+diffprep/__init__.py,sha256=ae5023179478a2c3015a16db9290d04ded463f174638aee7bec69028aa39b9d3,86
+diffprep/cli/app.py,sha256=bd5eb296358e0817873b75ce91e5a77b2f6cf5b679fa1ac4a8cf3673d1c79db1,428
+diffprep/cli/commands/_normalize.py,sha256=5a397f1c3a183ef34a82ab03f6b9640167cc924dce1ef569df00828cb1928723,1127
+diffprep/cli/commands/init.py,sha256=a42d42aa1c01c1be17da529fd734bbef881357954aba141356282b456582a5ce,3742
+diffprep/cli/commands/json.py,sha256=2e79f65ec1ad0b3f77de8812427602bdf6a0fd4c936175645999f3cb9107b27b,984
+diffprep/cli/commands/xml.py,sha256=694feaf318a22b5729ea38da9c88381508e2fe9a30541b9cc899e91e9fdf43e6,645
+diffprep/cli/completion.py,sha256=2731db28cf73d32e7ad8397b31ba9ebe54e86ca80d9a501e4966241e7730432b,1026
+diffprep/cli/io.py,sha256=ecf92f29c60ce670787f6d34ee0530cb8cd565f49bf4cd493f0a0151a6ac8ca4,251
+diffprep/cli/models.py,sha256=02535abeab728ac3d05d2c499db9877cbd36b8a989bcd605210e0047d131b3b0,1838
+diffprep/cli/prompting.py,sha256=19f20ef46befae7f4234dd6967b878be1cea32e771a79bcbe58e0e99b6c1e245,3536
+diffprep/core/__init__.py,sha256=6e5ac018f653d13f10a47c68af4e12154004402abec8e16fda658c63f91a2753,961
+diffprep/core/configs.py,sha256=daa7c4a41dd4d076a03d403362b8b420fca910ebd0063ab84c39435565afd226,4279
+diffprep/core/logger.py,sha256=0e4010e4c99d4493e9a80d30cc47281f5514bc3e6662f1e2089aff25cf9b473c,808
+diffprep/processors/__init__.py,sha256=0a6a68ffa8c21dfb998b46a92d051aecdbaf844ca5d36be028c92a80947b4c46,779
+diffprep/processors/_registry.py,sha256=82d7a629a085c93577a3752706cbaa4faef56765160d96d6cd524e974a71b93c,1753
+diffprep/processors/_types.py,sha256=e85ee032683798a7718a20f6f8217a73b5fa0158dbe654a28ff0833166936efb,566
+diffprep/processors/json.py,sha256=f35770265735d021e2df8c1bb2fed6d1423bc26c28e3402e79ee4830b7a6626d,1755
+diffprep/processors/xml.py,sha256=5eb4ee7a380ed778772e1da62acc435022c1af1b038cac111bc59c0a1eb7d105,349
+diffprep/types.py,sha256=113c354a7d01effc3f43312c6e0ffa3fce683e6d554a343b15503920c8d189e4,186
+diffprep-0.1.0a1.dist-info/WHEEL,sha256=607c46fee47e440c91332c738096ff0f5e54ca3b0818ee85462dd5172a38e793,79
+diffprep-0.1.0a1.dist-info/entry_points.txt,sha256=a0f058d64ab9b216d0c0f467d6ef3c43f507cb04a55ba62746f839928d2557fa,51
+diffprep-0.1.0a1.dist-info/METADATA,sha256=eccd31501288eeebf218ba2f2b6708cfa69bb6cb27914172617cb55faedccc4c,2559
+diffprep-0.1.0a1.dist-info/RECORD,,

diffprep-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.7.19
+Root-Is-Purelib: true
+Tag: py3-none-any

diffprep-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+diffprep = diffprep.cli.app:app
+