HTML to Plain Text Extractor (java, written by Claude Code)

diff --git a/pom.xml b/pom.xml
index 7a1e945..0284e57 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,6 +50,7 @@
                     </archive>
                 </configuration>
             </plugin>
+            <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-shade-plugin</artifactId><version>3.5.1</version><executions><execution><phase>package</phase><goals><goal>shade</goal></goals><configuration><transformers><transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"><mainClass>HtmlToTextExtractor</mainClass></transformer></transformers></configuration></execution></executions></plugin>
         </plugins>
     </build>
 </project>
--- /dev/null
+++ b/src/main/java/HtmlToTextExtractor.java
@@ -0,0 +1,320 @@
+import net.htmlparser.jericho.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.*;
+import java.util.regex.*;
+
+/**
+ * HTML to Plain Text Extractor using Jericho HTML Parser.
+ * Converts HTML documents to readable plain text with configurable formatting options.
+ */
+public class HtmlToTextExtractor {
+
+    private static final Logger logger = LoggerFactory.getLogger(HtmlToTextExtractor.class);
+
+    private static final Set<String> SKIP_TAGS = new HashSet<>(Arrays.asList(
+            "script", "style", "noscript", "iframe", "svg", "math", "template"
+    ));
+
+    private static final Set<String> BLOCK_TAGS = new HashSet<>(Arrays.asList(
+            "p", "div", "h1", "h2", "h3", "h4", "h5", "h6",
+            "ul", "ol", "li", "table", "tr", "blockquote", "pre",
+            "section", "article", "header", "footer", "nav", "aside",
+            "main", "figure", "figcaption", "br", "hr", "dd", "dt"
+    ));
+
+    private boolean preserveLinks;
+    private boolean preserveHeadings;
+    private boolean preserveLists;
+    private int lineWidth;
+
+    public HtmlToTextExtractor() {
+        this(false, false, false, 80);
+    }
+
+    public HtmlToTextExtractor(boolean preserveLinks, boolean preserveHeadings,
+                                boolean preserveLists, int lineWidth) {
+        this.preserveLinks = preserveLinks;
+        this.preserveHeadings = preserveHeadings;
+        this.preserveLists = preserveLists;
+        this.lineWidth = lineWidth;
+    }
+
+    public String extract(String htmlContent) {
+        logger.debug("Starting HTML extraction, input length: {}", htmlContent.length());
+        Source source = new Source(htmlContent);
+        source.fullSequentialParse();
+
+        StringBuilder result = new StringBuilder();
+        processSegments(source, result);
+
+        String text = cleanOutput(result.toString());
+        logger.info("Extraction complete. Output length: {}", text.length());
+        return text;
+    }
+
+    private void processSegments(Source source, StringBuilder result) {
+        List<Element> allElements = source.getAllElements();
+
+        for (Element element : source.getChildElements()) {
+            processElement(element, result, 0);
+        }
+
+        if (result.length() == 0) {
+            Renderer renderer = source.getRenderer();
+            renderer.setMaxLineLength(lineWidth > 0 ? lineWidth : Integer.MAX_VALUE);
+            renderer.setIncludeHyperlinkURLs(preserveLinks);
+            result.append(renderer.toString());
+        }
+    }
+
+    private void processElement(Element element, StringBuilder result, int depth) {
+        String tagName = element.getName().toLowerCase();
+
+        if (SKIP_TAGS.contains(tagName)) {
+            logger.trace("Skipping element: {}", tagName);
+            return;
+        }
+
+        boolean isBlock = BLOCK_TAGS.contains(tagName);
+
+        if (tagName.equals("br")) {
+            result.append("\n");
+            return;
+        }
+
+        if (tagName.equals("hr")) {
+            result.append("\n");
+            for (int i = 0; i < Math.min(lineWidth, 40); i++) {
+                result.append("-");
+            }
+            result.append("\n");
+            return;
+        }
+
+        if (isBlock) {
+            result.append("\n");
+        }
+
+        if (preserveHeadings && tagName.matches("h[1-6]")) {
+            int level = Character.getNumericValue(tagName.charAt(1));
+            String headingText = element.getTextExtractor().toString().trim();
+            if (!headingText.isEmpty()) {
+                result.append("\n");
+                for (int i = 0; i < level; i++) {
+                    result.append("#");
+                }
+                result.append(" ").append(headingText).append("\n\n");
+            }
+            return;
+        }
+
+        if (preserveLinks && tagName.equals("a")) {
+            String href = element.getAttributeValue("href");
+            String linkText = element.getTextExtractor().toString().trim();
+            if (href != null && !linkText.isEmpty()) {
+                result.append(linkText).append(" [").append(href).append("]");
+            } else if (!linkText.isEmpty()) {
+                result.append(linkText);
+            }
+            return;
+        }
+
+        if (preserveLists && tagName.equals("li")) {
+            Element parent = element.getParentElement();
+            String parentTag = parent != null ? parent.getName().toLowerCase() : "";
+            String prefix = parentTag.equals("ol") ? "  1. " : "  - ";
+            String itemText = element.getTextExtractor().toString().trim();
+            if (!itemText.isEmpty()) {
+                result.append(prefix).append(itemText).append("\n");
+            }
+            return;
+        }
+
+        List<Element> children = element.getChildElements();
+        if (children.isEmpty()) {
+            String text = element.getTextExtractor().toString();
+            if (!text.trim().isEmpty()) {
+                result.append(text);
+            }
+        } else {
+            for (Element child : children) {
+                processElement(child, result, depth + 1);
+            }
+        }
+
+        if (isBlock) {
+            result.append("\n");
+        }
+    }
+
+    public Map<String, String> extractMetadata(String htmlContent) {
+        Map<String, String> metadata = new LinkedHashMap<>();
+        Source source = new Source(htmlContent);
+
+        Element titleElement = source.getFirstElement("title");
+        if (titleElement != null) {
+            metadata.put("title", titleElement.getTextExtractor().toString().trim());
+        }
+
+        List<Element> metaElements = source.getAllElements("meta");
+        for (Element meta : metaElements) {
+            String name = meta.getAttributeValue("name");
+            String content = meta.getAttributeValue("content");
+            if (name != null && content != null) {
+                metadata.put(name.toLowerCase(), content);
+            }
+        }
+
+        logger.debug("Extracted {} metadata entries", metadata.size());
+        return metadata;
+    }
+
+    public String extractByTag(String htmlContent, String tagName) {
+        Source source = new Source(htmlContent);
+        List<Element> elements = source.getAllElements(tagName);
+        StringBuilder result = new StringBuilder();
+        for (Element element : elements) {
+            String text = element.getTextExtractor().toString().trim();
+            if (!text.isEmpty()) {
+                result.append(text).append("\n\n");
+            }
+        }
+        return result.toString().trim();
+    }
+
+    private String cleanOutput(String text) {
+        text = text.replaceAll("\\n{3,}", "\n\n");
+        text = text.replaceAll("[ \\t]+\\n", "\n");
+        text = text.trim();
+        return text;
+    }
+
+    public String wrapText(String text) {
+        if (lineWidth <= 0) return text;
+        StringBuilder wrapped = new StringBuilder();
+        for (String line : text.split("\\n")) {
+            if (line.length() <= lineWidth) {
+                wrapped.append(line).append("\n");
+            } else {
+                String[] words = line.split("\\s+");
+                StringBuilder current = new StringBuilder();
+                for (String word : words) {
+                    if (current.length() + word.length() + 1 > lineWidth && current.length() > 0) {
+                        wrapped.append(current.toString().trim()).append("\n");
+                        current = new StringBuilder();
+                    }
+                    current.append(word).append(" ");
+                }
+                if (current.length() > 0) {
+                    wrapped.append(current.toString().trim()).append("\n");
+                }
+            }
+        }
+        return wrapped.toString().trim();
+    }
+
+    public static void main(String[] args) {
+        boolean showLinks = false;
+        boolean showHeadings = false;
+        boolean showLists = false;
+        boolean showMeta = false;
+        boolean demo = false;
+        int width = 80;
+        String inputFile = null;
+        String outputFile = null;
+        String filterTag = null;
+
+        for (int i = 0; i < args.length; i++) {
+            switch (args[i]) {
+                case "--links": showLinks = true; break;
+                case "--headings": showHeadings = true; break;
+                case "--lists": showLists = true; break;
+                case "--meta": showMeta = true; break;
+                case "--demo": demo = true; break;
+                case "-w": case "--width":
+                    if (i + 1 < args.length) width = Integer.parseInt(args[++i]);
+                    break;
+                case "-o": case "--output":
+                    if (i + 1 < args.length) outputFile = args[++i];
+                    break;
+                case "-t": case "--tag":
+                    if (i + 1 < args.length) filterTag = args[++i];
+                    break;
+                default:
+                    if (!args[i].startsWith("-")) inputFile = args[i];
+            }
+        }
+
+        HtmlToTextExtractor extractor = new HtmlToTextExtractor(
+                showLinks, showHeadings, showLists, width
+        );
+
+        String htmlContent;
+        if (demo) {
+            htmlContent = "<html><head><title>Demo</title>"
+                    + "<meta name=\"author\" content=\"Test\">"
+                    + "</head><body>"
+                    + "<h1>Demo Document</h1>"
+                    + "<p>This is a <strong>demonstration</strong> of the extractor.</p>"
+                    + "<ul><li>Item one</li><li>Item two</li></ul>"
+                    + "<p>See <a href=\"https://example.com\">example</a>.</p>"
+                    + "<script>var x = 1;</script>"
+                    + "</body></html>";
+        } else if (inputFile != null) {
+            try {
+                htmlContent = new String(Files.readAllBytes(Paths.get(inputFile)), StandardCharsets.UTF_8);
+            } catch (IOException e) {
+                logger.error("Failed to read file: {}", inputFile, e);
+                System.err.println("Error reading file: " + e.getMessage());
+                return;
+            }
+        } else {
+            try (Scanner scanner = new Scanner(System.in, "UTF-8")) {
+                StringBuilder sb = new StringBuilder();
+                while (scanner.hasNextLine()) {
+                    sb.append(scanner.nextLine()).append("\n");
+                }
+                htmlContent = sb.toString();
+            }
+        }
+
+        String result;
+        if (filterTag != null) {
+            result = extractor.extractByTag(htmlContent, filterTag);
+        } else {
+            result = extractor.extract(htmlContent);
+        }
+
+        if (width > 0) {
+            result = extractor.wrapText(result);
+        }
+
+        StringBuilder output = new StringBuilder();
+        if (showMeta) {
+            Map<String, String> meta = extractor.extractMetadata(htmlContent);
+            if (!meta.isEmpty()) {
+                output.append("=== Document Metadata ===\n");
+                meta.forEach((k, v) -> output.append("  ").append(k).append(": ").append(v).append("\n"));
+                output.append("=".repeat(25)).append("\n\n");
+            }
+        }
+        output.append(result);
+
+        if (outputFile != null) {
+            try {
+                Files.write(Paths.get(outputFile), output.toString().getBytes(StandardCharsets.UTF_8));
+                System.out.println("Output written to " + outputFile);
+            } catch (IOException e) {
+                logger.error("Failed to write output file: {}", outputFile, e);
+                System.err.println("Error writing file: " + e.getMessage());
+            }
+        } else {
+            System.out.println(output.toString());
+        }
+    }
+}

Claude Code wrote this java project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: HTML to Plain Text Extractor

Write a program that converts HTML documents to clean plain text, intelligently handling formatting, tables, lists, and links while removing all markup and scripts.

FUNCTIONAL REQUIREMENTS:
- Accept an HTML file path as a command-line argument
- Strip all HTML tags, CSS styles, JavaScript, and comments while preserving readable text content
- Convert HTML formatting to plain text equivalents: headings become UPPERCASE with underlines, bold text is wrapped in *asterisks*, lists become indented with bullets (- ) or numbers (1.), horizontal rules become dashed lines
- Convert HTML tables to aligned plain text tables with column padding and separator rows
- Convert hyperlinks to "text [URL]" format, or optionally strip URLs via --no-urls flag
- Preserve paragraph spacing: consecutive block elements get blank line separators
- Handle HTML entities: decode & < >   — etc. to their text equivalents
- Support extracting text from only specific HTML elements via --selector flag (CSS selector syntax, e.g., --selector "article" or --selector ".content")
- Support extracting and listing all URLs found in the document via --extract-urls flag
- Set maximum line width via --width flag (default: 80 characters) with word wrapping
- Support batch conversion of multiple HTML files via --batch flag
- Print the plain text output to console by default
- Save to a file via --output flag (default: same base name with .txt extension)
- If no input is given, generate a sample HTML page with headings, paragraphs, links, tables, lists, images, inline styles, scripts, and HTML entities, then convert it and display both the original HTML and the extracted text
- Handle errors: malformed HTML (parse gracefully), encoding detection, and binary file detection

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

[
  {
    "category": "misspecification",
    "rule": "signature.build_layout_mismatch",
    "source": "failure_signature",
    "excerpt": "error: no classes were compiled"
  }
]

import net.htmlparser.jericho.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.util.regex.*;

/**
 * HTML to Plain Text Extractor using Jericho HTML Parser.
 * Converts HTML documents to readable plain text with configurable formatting options.
 */
public class HtmlToTextExtractor {

    private static final Logger logger = LoggerFactory.getLogger(HtmlToTextExtractor.class);

    private static final Set<String> SKIP_TAGS = new HashSet<>(Arrays.asList(
            "script", "style", "noscript", "iframe", "svg", "math", "template"
    ));

    private static final Set<String> BLOCK_TAGS = new HashSet<>(Arrays.asList(
            "p", "div", "h1", "h2", "h3", "h4", "h5", "h6",
            "ul", "ol", "li", "table", "tr", "blockquote", "pre",
            "section", "article", "header", "footer", "nav", "aside",
            "main", "figure", "figcaption", "br", "hr", "dd", "dt"
    ));

    private boolean preserveLinks;
    private boolean preserveHeadings;
    private boolean preserveLists;
    private int lineWidth;

    public HtmlToTextExtractor() {
        this(false, false, false, 80);
    }

    public HtmlToTextExtractor(boolean preserveLinks, boolean preserveHeadings,
                                boolean preserveLists, int lineWidth) {
        this.preserveLinks = preserveLinks;
        this.preserveHeadings = preserveHeadings;
        this.preserveLists = preserveLists;
        this.lineWidth = lineWidth;
    }

    public String extract(String htmlContent) {
        logger.debug("Starting HTML extraction, input length: {}", htmlContent.length());
        Source source = new Source(htmlContent);
        source.fullSequentialParse();

        StringBuilder result = new StringBuilder();
        processSegments(source, result);

        String text = cleanOutput(result.toString());
        logger.info("Extraction complete. Output length: {}", text.length());
        return text;
    }

    private void processSegments(Source source, StringBuilder result) {
        List<Element> allElements = source.getAllElements();

        for (Element element : source.getChildElements()) {
            processElement(element, result, 0);
        }

        if (result.length() == 0) {
            Renderer renderer = source.getRenderer();
            renderer.setMaxLineLength(lineWidth > 0 ? lineWidth : Integer.MAX_VALUE);
            renderer.setIncludeHyperlinkURLs(preserveLinks);
            result.append(renderer.toString());
        }
    }

    private void processElement(Element element, StringBuilder result, int depth) {
        String tagName = element.getName().toLowerCase();

        if (SKIP_TAGS.contains(tagName)) {
            logger.trace("Skipping element: {}", tagName);
            return;
        }

        boolean isBlock = BLOCK_TAGS.contains(tagName);

        if (tagName.equals("br")) {
            result.append("\n");
            return;
        }

        if (tagName.equals("hr")) {
            result.append("\n");
            for (int i = 0; i < Math.min(lineWidth, 40); i++) {
                result.append("-");
            }
            result.append("\n");
            return;
        }

        if (isBlock) {
            result.append("\n");
        }

        if (preserveHeadings && tagName.matches("h[1-6]")) {
            int level = Character.getNumericValue(tagName.charAt(1));
            String headingText = element.getTextExtractor().toString().trim();
            if (!headingText.isEmpty()) {
                result.append("\n");
                for (int i = 0; i < level; i++) {
                    result.append("#");
                }
                result.append(" ").append(headingText).append("\n\n");
            }
            return;
        }

        if (preserveLinks && tagName.equals("a")) {
            String href = element.getAttributeValue("href");
            String linkText = element.getTextExtractor().toString().trim();
            if (href != null && !linkText.isEmpty()) {
                result.append(linkText).append(" [").append(href).append("]");
            } else if (!linkText.isEmpty()) {
                result.append(linkText);
            }
            return;
        }

        if (preserveLists && tagName.equals("li")) {
            Element parent = element.getParentElement();
            String parentTag = parent != null ? parent.getName().toLowerCase() : "";
            String prefix = parentTag.equals("ol") ? "  1. " : "  - ";
            String itemText = element.getTextExtractor().toString().trim();
            if (!itemText.isEmpty()) {
                result.append(prefix).append(itemText).append("\n");
            }
            return;
        }

        List<Element> children = element.getChildElements();
        if (children.isEmpty()) {
            String text = element.getTextExtractor().toString();
            if (!text.trim().isEmpty()) {
                result.append(text);
            }
        } else {
            for (Element child : children) {
                processElement(child, result, depth + 1);
            }
        }

        if (isBlock) {
            result.append("\n");
        }
    }

    public Map<String, String> extractMetadata(String htmlContent) {
        Map<String, String> metadata = new LinkedHashMap<>();
        Source source = new Source(htmlContent);

        Element titleElement = source.getFirstElement("title");
        if (titleElement != null) {
            metadata.put("title", titleElement.getTextExtractor().toString().trim());
        }

        List<Element> metaElements = source.getAllElements("meta");
        for (Element meta : metaElements) {
            String name = meta.getAttributeValue("name");
            String content = meta.getAttributeValue("content");
            if (name != null && content != null) {
                metadata.put(name.toLowerCase(), content);
            }
        }

        logger.debug("Extracted {} metadata entries", metadata.size());
        return metadata;
    }

    public String extractByTag(String htmlContent, String tagName) {
        Source source = new Source(htmlContent);
        List<Element> elements = source.getAllElements(tagName);
        StringBuilder result = new StringBuilder();
        for (Element element : elements) {
            String text = element.getTextExtractor().toString().trim();
            if (!text.isEmpty()) {
                result.append(text).append("\n\n");
            }
        }
        return result.toString().trim();
    }

    private String cleanOutput(String text) {
        text = text.replaceAll("\\n{3,}", "\n\n");
        text = text.replaceAll("[ \\t]+\\n", "\n");
        text = text.trim();
        return text;
    }

    public String wrapText(String text) {
        if (lineWidth <= 0) return text;
        StringBuilder wrapped = new StringBuilder();
        for (String line : text.split("\\n")) {
            if (line.length() <= lineWidth) {
                wrapped.append(line).append("\n");
            } else {
                String[] words = line.split("\\s+");
                StringBuilder current = new StringBuilder();
                for (String word : words) {
                    if (current.length() + word.length() + 1 > lineWidth && current.length() > 0) {
                        wrapped.append(current.toString().trim()).append("\n");
                        current = new StringBuilder();
                    }
                    current.append(word).append(" ");
                }
                if (current.length() > 0) {
                    wrapped.append(current.toString().trim()).append("\n");
                }
            }
        }
        return wrapped.toString().trim();
    }

    public static void main(String[] args) {
        boolean showLinks = false;
        boolean showHeadings = false;
        boolean showLists = false;
        boolean showMeta = false;
        boolean demo = false;
        int width = 80;
        String inputFile = null;
        String outputFile = null;
        String filterTag = null;

        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "--links": showLinks = true; break;
                case "--headings": showHeadings = true; break;
                case "--lists": showLists = true; break;
                case "--meta": showMeta = true; break;
                case "--demo": demo = true; break;
                case "-w": case "--width":
                    if (i + 1 < args.length) width = Integer.parseInt(args[++i]);
                    break;
                case "-o": case "--output":
                    if (i + 1 < args.length) outputFile = args[++i];
                    break;
                case "-t": case "--tag":
                    if (i + 1 < args.length) filterTag = args[++i];
                    break;
                default:
                    if (!args[i].startsWith("-")) inputFile = args[i];
            }
        }

        HtmlToTextExtractor extractor = new HtmlToTextExtractor(
                showLinks, showHeadings, showLists, width
        );

        String htmlContent;
        if (demo) {
            htmlContent = "<html><head><title>Demo</title>"
                    + "<meta name=\"author\" content=\"Test\">"
                    + "</head><body>"
                    + "<h1>Demo Document</h1>"
                    + "<p>This is a <strong>demonstration</strong> of the extractor.</p>"
                    + "<ul><li>Item one</li><li>Item two</li></ul>"
                    + "<p>See <a href=\"https://example.com\">example</a>.</p>"
                    + "<script>var x = 1;</script>"
                    + "</body></html>";
        } else if (inputFile != null) {
            try {
                htmlContent = new String(Files.readAllBytes(Paths.get(inputFile)), StandardCharsets.UTF_8);
            } catch (IOException e) {
                logger.error("Failed to read file: {}", inputFile, e);
                System.err.println("Error reading file: " + e.getMessage());
                return;
            }
        } else {
            try (Scanner scanner = new Scanner(System.in, "UTF-8")) {
                StringBuilder sb = new StringBuilder();
                while (scanner.hasNextLine()) {
                    sb.append(scanner.nextLine()).append("\n");
                }
                htmlContent = sb.toString();
            }
        }

        String result;
        if (filterTag != null) {
            result = extractor.extractByTag(htmlContent, filterTag);
        } else {
            result = extractor.extract(htmlContent);
        }

        if (width > 0) {
            result = extractor.wrapText(result);
        }

        StringBuilder output = new StringBuilder();
        if (showMeta) {
            Map<String, String> meta = extractor.extractMetadata(htmlContent);
            if (!meta.isEmpty()) {
                output.append("=== Document Metadata ===\n");
                meta.forEach((k, v) -> output.append("  ").append(k).append(": ").append(v).append("\n"));
                output.append("=".repeat(25)).append("\n\n");
            }
        }
        output.append(result);

        if (outputFile != null) {
            try {
                Files.write(Paths.get(outputFile), output.toString().getBytes(StandardCharsets.UTF_8));
                System.out.println("Output written to " + outputFile);
            } catch (IOException e) {
                logger.error("Failed to write output file: {}", outputFile, e);
                System.err.println("Error writing file: " + e.getMessage());
            }
        } else {
            System.out.println(output.toString());
        }
    }
}

<?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>com.example</groupId>
    <artifactId>html-to-text-extractor</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>HTML to Plain Text Extractor</name>
    <description>Extracts plain text from HTML using Jericho HTML Parser</description>

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

    <dependencies>
        <dependency>
            <groupId>net.htmlparser.jericho</groupId>
            <artifactId>jericho-html</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.9</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>2.0.9</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>HtmlToTextExtractor</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# HTML to Plain Text Extractor (Java - Trial 3)

## Description
A command-line tool that extracts readable plain text from HTML documents using Jericho HTML Parser with SLF4J logging.

## Dependencies
- **jericho-html-parser**: Open-source HTML parser for Java with support for non-well-formed HTML
- **slf4j**: Simple Logging Facade for Java, providing configurable logging

## Build & Run
```bash
mvn clean compile exec:java -Dexec.mainClass="HtmlToTextExtractor"
```

## Usage
```bash
# Extract text from a file
java HtmlToTextExtractor input.html

# Run demo mode
java HtmlToTextExtractor --demo

# Preserve links and headings
java HtmlToTextExtractor input.html --links --headings

# Filter by tag
java HtmlToTextExtractor input.html -t p

# Set line width
java HtmlToTextExtractor input.html -w 120
```

## Features
- Jericho-based HTML parsing for malformed HTML support
- Tag-based text filtering
- Metadata extraction
- Configurable line wrapping
- SLF4J-based logging