Cron Expression Parser (java, written by Claude Code)

--- /dev/null
+++ b/src/main/java/CronParser.java
@@ -0,0 +1,329 @@
+/**
+ * Cron Expression Parser
+ * Parses/validates cron expressions, computes next execution times,
+ * and generates human-readable descriptions.
+ * Uses Quartz Scheduler for cron parsing and SLF4J for logging.
+ */
+
+import org.quartz.CronExpression;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+public class CronParser {
+
+    private static final Logger logger = LoggerFactory.getLogger(CronParser.class);
+    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+    private static final Map<String, String> PREDEFINED = new HashMap<>();
+    static {
+        PREDEFINED.put("@yearly", "0 0 0 1 1 ? *");
+        PREDEFINED.put("@annually", "0 0 0 1 1 ? *");
+        PREDEFINED.put("@monthly", "0 0 0 1 * ? *");
+        PREDEFINED.put("@weekly", "0 0 0 ? * SUN *");
+        PREDEFINED.put("@daily", "0 0 0 * * ? *");
+        PREDEFINED.put("@hourly", "0 0 * * * ? *");
+    }
+
+    private static final String[] MONTH_NAMES = {
+        "", "January", "February", "March", "April", "May", "June",
+        "July", "August", "September", "October", "November", "December"
+    };
+
+    private static final String[] DAY_NAMES = {
+        "", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+    };
+
+    private String originalExpression;
+    private String normalizedExpression;
+    private CronExpression quartzCron;
+    private boolean valid;
+    private String errorMessage;
+
+    public CronParser(String expression) {
+        this.originalExpression = expression.trim();
+        this.normalizedExpression = normalize(this.originalExpression);
+        this.valid = false;
+        this.errorMessage = "";
+        parse();
+    }
+
+    private String normalize(String expr) {
+        String lower = expr.toLowerCase();
+        if (PREDEFINED.containsKey(lower)) {
+            return PREDEFINED.get(lower);
+        }
+        // Convert 5-field unix cron to 6-field Quartz format if needed
+        String[] parts = expr.trim().split("\\s+");
+        if (parts.length == 5) {
+            // Add seconds field at the beginning and adjust day-of-week
+            return "0 " + expr + " *";
+        }
+        return expr;
+    }
+
+    private void parse() {
+        try {
+            this.quartzCron = new CronExpression(this.normalizedExpression);
+            this.valid = true;
+            logger.info("Successfully parsed cron expression: {}", originalExpression);
+        } catch (ParseException e) {
+            this.valid = false;
+            this.errorMessage = e.getMessage();
+            logger.warn("Failed to parse cron expression '{}': {}", originalExpression, errorMessage);
+        }
+    }
+
+    public boolean isValid() {
+        return valid;
+    }
+
+    public String getErrorMessage() {
+        return errorMessage;
+    }
+
+    public List<Date> getNextOccurrences(int count) {
+        return getNextOccurrences(count, new Date());
+    }
+
+    public List<Date> getNextOccurrences(int count, Date baseTime) {
+        List<Date> results = new ArrayList<>();
+        if (!valid) return results;
+
+        Date current = baseTime;
+        for (int i = 0; i < count; i++) {
+            Date next = quartzCron.getNextValidTimeAfter(current);
+            if (next == null) break;
+            results.add(next);
+            current = next;
+        }
+        return results;
+    }
+
+    public long getTimeUntilNext() {
+        return getTimeUntilNext(new Date());
+    }
+
+    public long getTimeUntilNext(Date baseTime) {
+        if (!valid) return -1;
+        Date next = quartzCron.getNextValidTimeAfter(baseTime);
+        if (next == null) return -1;
+        return next.getTime() - baseTime.getTime();
+    }
+
+    public boolean matchesTime(Date date) {
+        if (!valid) return false;
+        return quartzCron.isSatisfiedBy(date);
+    }
+
+    public List<Date> getOccurrencesInRange(Date start, Date end) {
+        List<Date> results = new ArrayList<>();
+        if (!valid) return results;
+
+        Date current = start;
+        while (true) {
+            Date next = quartzCron.getNextValidTimeAfter(current);
+            if (next == null || next.after(end)) break;
+            results.add(next);
+            current = next;
+        }
+        return results;
+    }
+
+    public int getFrequencyPerDay() {
+        Calendar cal = Calendar.getInstance();
+        cal.set(Calendar.HOUR_OF_DAY, 0);
+        cal.set(Calendar.MINUTE, 0);
+        cal.set(Calendar.SECOND, 0);
+        cal.set(Calendar.MILLISECOND, 0);
+        Date start = cal.getTime();
+        cal.add(Calendar.DAY_OF_MONTH, 1);
+        Date end = cal.getTime();
+        return getOccurrencesInRange(start, end).size();
+    }
+
+    public String describe() {
+        if (!valid) return "Invalid expression: " + errorMessage;
+
+        String[] parts = normalizedExpression.trim().split("\\s+");
+        List<String> descriptions = new ArrayList<>();
+
+        if (parts.length >= 6) {
+            String seconds = parts[0];
+            String minutes = parts[1];
+            String hours = parts[2];
+            String dayOfMonth = parts[3];
+            String month = parts[4];
+            String dayOfWeek = parts[5];
+
+            if (!minutes.equals("*")) descriptions.add(describeField(minutes, "minute"));
+            if (!hours.equals("*")) descriptions.add(describeField(hours, "hour"));
+            if (!dayOfMonth.equals("*") && !dayOfMonth.equals("?"))
+                descriptions.add(describeField(dayOfMonth, "day"));
+            if (!month.equals("*")) descriptions.add(describeField(month, "month"));
+            if (!dayOfWeek.equals("*") && !dayOfWeek.equals("?"))
+                descriptions.add(describeField(dayOfWeek, "weekday"));
+        }
+
+        return descriptions.isEmpty() ? "Every second" : String.join(", ", descriptions);
+    }
+
+    private String describeField(String value, String fieldName) {
+        if (value.contains("/")) {
+            String[] split = value.split("/");
+            return "every " + split[1] + " " + fieldName + "(s)";
+        }
+        if (value.contains("-")) {
+            String[] split = value.split("-");
+            return fieldName + " " + split[0] + " through " + split[1];
+        }
+        if (value.contains(",")) {
+            return fieldName + " " + value;
+        }
+        return "at " + fieldName + " " + value;
+    }
+
+    public Map<String, Object> toMap() {
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("original", originalExpression);
+        map.put("normalized", normalizedExpression);
+        map.put("valid", valid);
+        if (valid) {
+            map.put("description", describe());
+            map.put("frequencyPerDay", getFrequencyPerDay());
+            List<String> nextTimes = new ArrayList<>();
+            for (Date d : getNextOccurrences(5)) {
+                nextTimes.add(DATE_FORMAT.format(d));
+            }
+            map.put("nextOccurrences", nextTimes);
+        } else {
+            map.put("error", errorMessage);
+        }
+        return map;
+    }
+
+    public void printAnalysis(int count) {
+        System.out.println("=== Cron Expression Analysis ===");
+        System.out.println("Expression:  " + originalExpression);
+        System.out.println("Normalized:  " + normalizedExpression);
+        System.out.println("Valid:       " + valid);
+
+        if (!valid) {
+            System.out.println("Error:       " + errorMessage);
+            return;
+        }
+
+        System.out.println("Description: " + describe());
+        System.out.println();
+
+        // Next occurrences
+        System.out.println("Next " + count + " executions:");
+        Date now = new Date();
+        List<Date> nextTimes = getNextOccurrences(count);
+        for (int i = 0; i < nextTimes.size(); i++) {
+            Date d = nextTimes.get(i);
+            long diffMs = d.getTime() - now.getTime();
+            long diffMins = TimeUnit.MILLISECONDS.toMinutes(diffMs);
+            String relative;
+            if (diffMins < 60) {
+                relative = "in " + diffMins + " minutes";
+            } else if (diffMins < 1440) {
+                relative = "in " + (diffMins / 60) + " hours";
+            } else {
+                relative = "in " + (diffMins / 1440) + " days";
+            }
+            System.out.printf("  [%d] %s (%s)%n", i + 1, DATE_FORMAT.format(d), relative);
+        }
+
+        System.out.println();
+        System.out.println("Statistics:");
+        System.out.println("  Executions/day:   " + getFrequencyPerDay());
+        System.out.println("  Executions/week:  " + (getFrequencyPerDay() * 7));
+
+        long msToNext = getTimeUntilNext();
+        if (msToNext > 0) {
+            long secsToNext = TimeUnit.MILLISECONDS.toSeconds(msToNext);
+            System.out.println("  Time to next:     " + secsToNext + " seconds");
+        }
+
+        System.out.println("================================");
+    }
+
+    public static void main(String[] args) {
+        if (args.length < 1) {
+            System.out.println("Cron Expression Parser");
+            System.out.println("Usage:");
+            System.out.println("  java CronParser parse \"<expression>\" [count]");
+            System.out.println("  java CronParser validate \"<expression>\"");
+            System.out.println("  java CronParser next \"<expression>\" [count]");
+            System.out.println("  java CronParser describe \"<expression>\"");
+            System.out.println();
+            System.out.println("Examples:");
+            System.out.println("  java CronParser parse \"*/5 * * * *\"");
+            System.out.println("  java CronParser validate \"0 0 * * *\"");
+            System.out.println("  java CronParser next \"30 8 * * 1-5\" 10");
+            return;
+        }
+
+        String command = args[0];
+
+        switch (command) {
+            case "parse": {
+                if (args.length < 2) {
+                    System.err.println("Missing expression argument");
+                    System.exit(1);
+                }
+                int count = args.length >= 3 ? Integer.parseInt(args[2]) : 10;
+                CronParser parser = new CronParser(args[1]);
+                parser.printAnalysis(count);
+                break;
+            }
+            case "validate": {
+                if (args.length < 2) {
+                    System.err.println("Missing expression argument");
+                    System.exit(1);
+                }
+                CronParser parser = new CronParser(args[1]);
+                if (parser.isValid()) {
+                    System.out.println("VALID: " + parser.describe());
+                } else {
+                    System.out.println("INVALID: " + parser.getErrorMessage());
+                    System.exit(1);
+                }
+                break;
+            }
+            case "next": {
+                if (args.length < 2) {
+                    System.err.println("Missing expression argument");
+                    System.exit(1);
+                }
+                int count = args.length >= 3 ? Integer.parseInt(args[2]) : 5;
+                CronParser parser = new CronParser(args[1]);
+                if (!parser.isValid()) {
+                    System.err.println("Invalid: " + parser.getErrorMessage());
+                    System.exit(1);
+                }
+                for (Date d : parser.getNextOccurrences(count)) {
+                    System.out.println(DATE_FORMAT.format(d));
+                }
+                break;
+            }
+            case "describe": {
+                if (args.length < 2) {
+                    System.err.println("Missing expression argument");
+                    System.exit(1);
+                }
+                CronParser parser = new CronParser(args[1]);
+                System.out.println(parser.describe());
+                break;
+            }
+            default:
+                System.err.println("Unknown command: " + command);
+                System.exit(1);
+        }
+    }
+}

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: Cron Expression Parser

Write a program that parses, validates, and explains cron expressions, computing the next N execution times and generating human-readable descriptions of the schedule.

FUNCTIONAL REQUIREMENTS:
- Accept a cron expression as a command-line argument (standard 5-field format: minute, hour, day-of-month, month, day-of-week)
- Support extended 6-field format with seconds as the first field via --with-seconds flag
- Support special characters: * (all), , (list), - (range), / (step), L (last), W (nearest weekday), # (nth day of week), and ? (any)
- Validate the expression and report clear errors for invalid fields with the specific position and reason (e.g., "Field 2 (hour): value 25 exceeds maximum 23")
- Compute and display the next N execution times via --next flag (default: 10), formatted in ISO 8601 and local human-readable format, relative to current time or a specified start time via --from flag
- Generate a human-readable English description of the schedule (e.g., "At 03:30 AM, every Monday and Wednesday, in January through March")
- Support time zone handling via --timezone flag (default: UTC)
- Compute the interval statistics: average gap between executions, minimum gap, maximum gap, total executions per day/week/month/year
- Support checking if a specific datetime matches the cron expression via --check flag
- Support converting between cron expression and a verbal description via --describe flag (cron to English) and --parse flag (English-like input to cron expression for common patterns)
- Print results to console in a formatted display
- Save results as JSON with --output flag (default: cron_analysis.json)
- Support batch validation of multiple expressions from a file via --batch flag
- If no expression is given, demonstrate with several example expressions: "*/5 * * * *" (every 5 minutes), "0 9 * * 1-5" (weekdays at 9am), "0 0 1,15 * *" (1st and 15th at midnight), "30 4 * * SUN" (Sundays at 4:30am), showing next 5 runs and descriptions for each
- Handle errors: invalid syntax, out-of-range values, impossible combinations (e.g., Feb 31), and malformed special characters

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"
  }
]

/**
 * Cron Expression Parser
 * Parses/validates cron expressions, computes next execution times,
 * and generates human-readable descriptions.
 * Uses Quartz Scheduler for cron parsing and SLF4J for logging.
 */

import org.quartz.CronExpression;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class CronParser {

    private static final Logger logger = LoggerFactory.getLogger(CronParser.class);
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private static final Map<String, String> PREDEFINED = new HashMap<>();
    static {
        PREDEFINED.put("@yearly", "0 0 0 1 1 ? *");
        PREDEFINED.put("@annually", "0 0 0 1 1 ? *");
        PREDEFINED.put("@monthly", "0 0 0 1 * ? *");
        PREDEFINED.put("@weekly", "0 0 0 ? * SUN *");
        PREDEFINED.put("@daily", "0 0 0 * * ? *");
        PREDEFINED.put("@hourly", "0 0 * * * ? *");
    }

    private static final String[] MONTH_NAMES = {
        "", "January", "February", "March", "April", "May", "June",
        "July", "August", "September", "October", "November", "December"
    };

    private static final String[] DAY_NAMES = {
        "", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
    };

    private String originalExpression;
    private String normalizedExpression;
    private CronExpression quartzCron;
    private boolean valid;
    private String errorMessage;

    public CronParser(String expression) {
        this.originalExpression = expression.trim();
        this.normalizedExpression = normalize(this.originalExpression);
        this.valid = false;
        this.errorMessage = "";
        parse();
    }

    private String normalize(String expr) {
        String lower = expr.toLowerCase();
        if (PREDEFINED.containsKey(lower)) {
            return PREDEFINED.get(lower);
        }
        // Convert 5-field unix cron to 6-field Quartz format if needed
        String[] parts = expr.trim().split("\\s+");
        if (parts.length == 5) {
            // Add seconds field at the beginning and adjust day-of-week
            return "0 " + expr + " *";
        }
        return expr;
    }

    private void parse() {
        try {
            this.quartzCron = new CronExpression(this.normalizedExpression);
            this.valid = true;
            logger.info("Successfully parsed cron expression: {}", originalExpression);
        } catch (ParseException e) {
            this.valid = false;
            this.errorMessage = e.getMessage();
            logger.warn("Failed to parse cron expression '{}': {}", originalExpression, errorMessage);
        }
    }

    public boolean isValid() {
        return valid;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public List<Date> getNextOccurrences(int count) {
        return getNextOccurrences(count, new Date());
    }

    public List<Date> getNextOccurrences(int count, Date baseTime) {
        List<Date> results = new ArrayList<>();
        if (!valid) return results;

        Date current = baseTime;
        for (int i = 0; i < count; i++) {
            Date next = quartzCron.getNextValidTimeAfter(current);
            if (next == null) break;
            results.add(next);
            current = next;
        }
        return results;
    }

    public long getTimeUntilNext() {
        return getTimeUntilNext(new Date());
    }

    public long getTimeUntilNext(Date baseTime) {
        if (!valid) return -1;
        Date next = quartzCron.getNextValidTimeAfter(baseTime);
        if (next == null) return -1;
        return next.getTime() - baseTime.getTime();
    }

    public boolean matchesTime(Date date) {
        if (!valid) return false;
        return quartzCron.isSatisfiedBy(date);
    }

    public List<Date> getOccurrencesInRange(Date start, Date end) {
        List<Date> results = new ArrayList<>();
        if (!valid) return results;

        Date current = start;
        while (true) {
            Date next = quartzCron.getNextValidTimeAfter(current);
            if (next == null || next.after(end)) break;
            results.add(next);
            current = next;
        }
        return results;
    }

    public int getFrequencyPerDay() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        Date start = cal.getTime();
        cal.add(Calendar.DAY_OF_MONTH, 1);
        Date end = cal.getTime();
        return getOccurrencesInRange(start, end).size();
    }

    public String describe() {
        if (!valid) return "Invalid expression: " + errorMessage;

        String[] parts = normalizedExpression.trim().split("\\s+");
        List<String> descriptions = new ArrayList<>();

        if (parts.length >= 6) {
            String seconds = parts[0];
            String minutes = parts[1];
            String hours = parts[2];
            String dayOfMonth = parts[3];
            String month = parts[4];
            String dayOfWeek = parts[5];

            if (!minutes.equals("*")) descriptions.add(describeField(minutes, "minute"));
            if (!hours.equals("*")) descriptions.add(describeField(hours, "hour"));
            if (!dayOfMonth.equals("*") && !dayOfMonth.equals("?"))
                descriptions.add(describeField(dayOfMonth, "day"));
            if (!month.equals("*")) descriptions.add(describeField(month, "month"));
            if (!dayOfWeek.equals("*") && !dayOfWeek.equals("?"))
                descriptions.add(describeField(dayOfWeek, "weekday"));
        }

        return descriptions.isEmpty() ? "Every second" : String.join(", ", descriptions);
    }

    private String describeField(String value, String fieldName) {
        if (value.contains("/")) {
            String[] split = value.split("/");
            return "every " + split[1] + " " + fieldName + "(s)";
        }
        if (value.contains("-")) {
            String[] split = value.split("-");
            return fieldName + " " + split[0] + " through " + split[1];
        }
        if (value.contains(",")) {
            return fieldName + " " + value;
        }
        return "at " + fieldName + " " + value;
    }

    public Map<String, Object> toMap() {
        Map<String, Object> map = new LinkedHashMap<>();
        map.put("original", originalExpression);
        map.put("normalized", normalizedExpression);
        map.put("valid", valid);
        if (valid) {
            map.put("description", describe());
            map.put("frequencyPerDay", getFrequencyPerDay());
            List<String> nextTimes = new ArrayList<>();
            for (Date d : getNextOccurrences(5)) {
                nextTimes.add(DATE_FORMAT.format(d));
            }
            map.put("nextOccurrences", nextTimes);
        } else {
            map.put("error", errorMessage);
        }
        return map;
    }

    public void printAnalysis(int count) {
        System.out.println("=== Cron Expression Analysis ===");
        System.out.println("Expression:  " + originalExpression);
        System.out.println("Normalized:  " + normalizedExpression);
        System.out.println("Valid:       " + valid);

        if (!valid) {
            System.out.println("Error:       " + errorMessage);
            return;
        }

        System.out.println("Description: " + describe());
        System.out.println();

        // Next occurrences
        System.out.println("Next " + count + " executions:");
        Date now = new Date();
        List<Date> nextTimes = getNextOccurrences(count);
        for (int i = 0; i < nextTimes.size(); i++) {
            Date d = nextTimes.get(i);
            long diffMs = d.getTime() - now.getTime();
            long diffMins = TimeUnit.MILLISECONDS.toMinutes(diffMs);
            String relative;
            if (diffMins < 60) {
                relative = "in " + diffMins + " minutes";
            } else if (diffMins < 1440) {
                relative = "in " + (diffMins / 60) + " hours";
            } else {
                relative = "in " + (diffMins / 1440) + " days";
            }
            System.out.printf("  [%d] %s (%s)%n", i + 1, DATE_FORMAT.format(d), relative);
        }

        System.out.println();
        System.out.println("Statistics:");
        System.out.println("  Executions/day:   " + getFrequencyPerDay());
        System.out.println("  Executions/week:  " + (getFrequencyPerDay() * 7));

        long msToNext = getTimeUntilNext();
        if (msToNext > 0) {
            long secsToNext = TimeUnit.MILLISECONDS.toSeconds(msToNext);
            System.out.println("  Time to next:     " + secsToNext + " seconds");
        }

        System.out.println("================================");
    }

    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("Cron Expression Parser");
            System.out.println("Usage:");
            System.out.println("  java CronParser parse \"<expression>\" [count]");
            System.out.println("  java CronParser validate \"<expression>\"");
            System.out.println("  java CronParser next \"<expression>\" [count]");
            System.out.println("  java CronParser describe \"<expression>\"");
            System.out.println();
            System.out.println("Examples:");
            System.out.println("  java CronParser parse \"*/5 * * * *\"");
            System.out.println("  java CronParser validate \"0 0 * * *\"");
            System.out.println("  java CronParser next \"30 8 * * 1-5\" 10");
            return;
        }

        String command = args[0];

        switch (command) {
            case "parse": {
                if (args.length < 2) {
                    System.err.println("Missing expression argument");
                    System.exit(1);
                }
                int count = args.length >= 3 ? Integer.parseInt(args[2]) : 10;
                CronParser parser = new CronParser(args[1]);
                parser.printAnalysis(count);
                break;
            }
            case "validate": {
                if (args.length < 2) {
                    System.err.println("Missing expression argument");
                    System.exit(1);
                }
                CronParser parser = new CronParser(args[1]);
                if (parser.isValid()) {
                    System.out.println("VALID: " + parser.describe());
                } else {
                    System.out.println("INVALID: " + parser.getErrorMessage());
                    System.exit(1);
                }
                break;
            }
            case "next": {
                if (args.length < 2) {
                    System.err.println("Missing expression argument");
                    System.exit(1);
                }
                int count = args.length >= 3 ? Integer.parseInt(args[2]) : 5;
                CronParser parser = new CronParser(args[1]);
                if (!parser.isValid()) {
                    System.err.println("Invalid: " + parser.getErrorMessage());
                    System.exit(1);
                }
                for (Date d : parser.getNextOccurrences(count)) {
                    System.out.println(DATE_FORMAT.format(d));
                }
                break;
            }
            case "describe": {
                if (args.length < 2) {
                    System.err.println("Missing expression argument");
                    System.exit(1);
                }
                CronParser parser = new CronParser(args[1]);
                System.out.println(parser.describe());
                break;
            }
            default:
                System.err.println("Unknown command: " + command);
                System.exit(1);
        }
    }
}

<?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>cron-parser</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>Cron Expression Parser</name>
    <description>Parses/validates cron expressions, computes next execution times, human-readable descriptions</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>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</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>CronParser</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

# Cron Expression Parser

Parses/validates cron expressions, computes next execution times, and generates human-readable descriptions.

## Dependencies
- **Quartz Scheduler** - Cron expression parsing and scheduling engine
- **SLF4J** - Logging facade with simple backend

## Usage

### Parse and analyze
```bash
java CronParser parse "*/5 * * * *" 10
```

### Validate expression
```bash
java CronParser validate "0 0 * * *"
```

### Show next execution times
```bash
java CronParser next "30 8 * * 1-5" 5
```

### Get description
```bash
java CronParser describe "0 0 1 * *"
```

## Build
```bash
mvn clean package
java -jar target/cron-parser-1.0.0.jar parse "*/10 * * * *"
```