XML to JSON Converter (java, written by Claude Code)

Claude Code wrote this java project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: XML to JSON Converter

Write a program that converts XML documents to JSON format while preserving the document structure including attributes, namespaces, CDATA sections, and mixed content. It should handle complex real-world XML with deeply nested elements.

FUNCTIONAL REQUIREMENTS:
- Accept an XML file path as a command-line argument
- Parse the full XML document including attributes, namespaces, text content, CDATA sections, and comments
- Convert to JSON preserving the hierarchy: elements become objects, repeated elements become arrays, attributes are prefixed with @ symbol, text content uses #text key
- Handle namespace prefixes by including them in key names
- Support converting multiple XML files in a directory via a --batch flag
- Print the resulting JSON to console with pretty-print formatting (indented)
- Save the output as a .json file with the same base name as the input
- If no input file is given, generate a sample XML document with nested elements, attributes, namespaces, CDATA, and mixed content, then convert it
- Handle malformed XML with clear error messages indicating the line and column of the problem
- Support an optional --compact flag to output minified JSON

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>converter</groupId>
    <artifactId>xml-to-json-converter-trial1</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>XML to JSON Converter - Trial 1</name>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jackson.version>2.16.1</jackson.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>${jackson.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>converter.XmlToJsonConverter</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.1.1</version>
                <configuration>
                    <mainClass>converter.XmlToJsonConverter</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# XML to JSON Converter - Java Trial 1

## Dependencies
- **Jackson Databind** (2.16.1): JSON processing
- **Jackson Dataformat XML** (2.16.1): XML parsing via Jackson

## Setup
```bash
mvn clean compile
```

## Usage
```bash
# Convert an XML file
mvn exec:java -Dexec.args="input.xml"

# Generate sample XML and convert
mvn exec:java
```

## Features
- Attribute preservation via Jackson XML
- Namespace handling
- CDATA handling
- Mixed content support
- Empty element handling
- Graceful malformed XML error reporting
- Pretty-printed JSON output saved to `output.json`

package converter;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * XML to JSON Converter - Trial 1
 * Uses Jackson XML (jackson-dataformat-xml) for XML parsing
 * and Jackson JSON (jackson-databind) for JSON output.
 * Preserves structure, attributes, namespaces, CDATA, and mixed content.
 */
public class XmlToJsonConverter {

    private static final String SAMPLE_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
            + "<!-- Root level comment -->\n"
            + "<catalog xmlns=\"http://example.com/catalog\"\n"
            + "         xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n"
            + "         version=\"2.0\">\n"
            + "    <!-- Book entry with attributes and namespaces -->\n"
            + "    <book id=\"bk101\" category=\"fiction\">\n"
            + "        <dc:title>XML Developer's Guide</dc:title>\n"
            + "        <dc:creator>Author Name</dc:creator>\n"
            + "        <price currency=\"USD\">44.95</price>\n"
            + "        <description><![CDATA[This is a <b>bold</b> description with <special> characters & entities.]]></description>\n"
            + "        <publish_date>2023-10-01</publish_date>\n"
            + "        <mixed>Text before <em>emphasis</em> and after.</mixed>\n"
            + "    </book>\n"
            + "    <book id=\"bk102\" category=\"non-fiction\">\n"
            + "        <dc:title>Learning XML</dc:title>\n"
            + "        <dc:creator>Another Author</dc:creator>\n"
            + "        <price currency=\"EUR\">39.95</price>\n"
            + "        <description><![CDATA[A comprehensive guide to XML & JSON.]]></description>\n"
            + "        <publish_date>2023-11-15</publish_date>\n"
            + "        <notes/>\n"
            + "        <tags>\n"
            + "            <tag>xml</tag>\n"
            + "            <tag>json</tag>\n"
            + "            <tag>converter</tag>\n"
            + "        </tags>\n"
            + "    </book>\n"
            + "    <!-- Empty element example -->\n"
            + "    <metadata>\n"
            + "        <empty_element/>\n"
            + "        <self_closing attr=\"value\"/>\n"
            + "    </metadata>\n"
            + "</catalog>\n";

    /**
     * Convert XML string to a JsonNode using Jackson's XmlMapper.
     */
    public static JsonNode convertXmlToJson(String xmlContent) throws IOException {
        XmlMapper xmlMapper = new XmlMapper();
        JsonNode node = xmlMapper.readTree(xmlContent.getBytes(StandardCharsets.UTF_8));
        return node;
    }

    /**
     * Pretty-print JsonNode and save to file.
     */
    public static String saveJson(JsonNode data, String outputPath) throws IOException {
        ObjectMapper jsonMapper = new ObjectMapper();
        jsonMapper.enable(SerializationFeature.INDENT_OUTPUT);
        String jsonStr = jsonMapper.writerWithDefaultPrettyPrinter().writeValueAsString(data);

        try (PrintWriter writer = new PrintWriter(new FileWriter(outputPath, StandardCharsets.UTF_8))) {
            writer.write(jsonStr);
        }
        System.out.println("JSON output saved to: " + outputPath);
        return jsonStr;
    }

    public static void main(String[] args) {
        String xmlContent;

        if (args.length > 0) {
            String inputFile = args[0];
            File file = new File(inputFile);
            if (!file.exists()) {
                System.err.println("Error: File '" + inputFile + "' not found.");
                System.exit(1);
            }
            try {
                xmlContent = new String(Files.readAllBytes(Paths.get(inputFile)), StandardCharsets.UTF_8);
                System.out.println("Reading XML from: " + inputFile);
            } catch (IOException e) {
                System.err.println("Error reading file: " + e.getMessage());
                System.exit(1);
                return;
            }
        } else {
            System.out.println("No input file provided. Using sample XML with all edge cases.");
            xmlContent = SAMPLE_XML;
            try (PrintWriter writer = new PrintWriter(new FileWriter("sample.xml", StandardCharsets.UTF_8))) {
                writer.write(xmlContent);
                System.out.println("Sample XML saved to: sample.xml");
            } catch (IOException e) {
                System.err.println("Error writing sample XML: " + e.getMessage());
            }
        }

        try {
            JsonNode result = convertXmlToJson(xmlContent);
            String jsonOutput = saveJson(result, "output.json");
            System.out.println("\n--- JSON Output ---");
            System.out.println(jsonOutput);
        } catch (IOException e) {
            System.err.println("Error: Malformed XML or conversion failure - " + e.getMessage());
            System.exit(1);
        }
    }
}