Program.cs

using System.Text.Json;
using System.Text.Json.Serialization;

var app = new TaskPilotApp(new JsonTaskStore(TaskStorePaths.DefaultPath));
return app.Run(args);

internal sealed class TaskPilotApp
{
    private readonly ITaskStore _store;

    public TaskPilotApp(ITaskStore store)
    {
        _store = store;
    }

    public int Run(string[] args)
    {
        if (args.Length == 0 || IsHelp(args[0]))
        {
            PrintHelp();
            return 0;
        }

        try
        {
            return args[0].ToLowerInvariant() switch
            {
                "add" => Add(args[1..]),
                "list" => List(args[1..]),
                "done" => MarkDone(args[1..]),
                "remove" or "rm" => Remove(args[1..]),
                "stats" => Stats(),
                _ => Fail($"Unknown command '{args[0]}'. Run 'taskpilot help' for usage.")
            };
        }
        catch (TaskPilotException ex)
        {
            return Fail(ex.Message);
        }
        catch (JsonException ex)
        {
            return Fail($"Task data is corrupt: {ex.Message}");
        }
    }

    private int Add(string[] args)
    {
        var options = CommandOptions.Parse(args);
        var title = options.PositionalText;

        if (string.IsNullOrWhiteSpace(title))
        {
            throw new TaskPilotException("Add needs a task title. Example: taskpilot add \"Pay invoice\" --due 2026-07-15");
        }

        var tasks = _store.Load();
        DateOnly? dueDate = options.Has("due") ? ParseDate(options.RequireValue("due")) : null;
        var priority = options.Get("priority") ?? options.Get("p") ?? "medium";

        if ((options.Has("priority") && options.Get("priority") is null) || (options.Has("p") && options.Get("p") is null))
        {
            throw new TaskPilotException("Priority needs a value: low, medium, or high.");
        }

        if (!Enum.TryParse<TaskPriority>(priority, ignoreCase: true, out var parsedPriority))
        {
            throw new TaskPilotException("Priority must be low, medium, or high.");
        }

        var task = new WorkTask
        {
            Id = NextId(tasks),
            Title = title,
            Priority = parsedPriority,
            DueDate = dueDate,
            CreatedAt = DateTimeOffset.Now
        };

        tasks.Add(task);
        _store.Save(tasks);

        Console.WriteLine($"Added #{task.Id}: {task.Title}");
        return 0;
    }

    private int List(string[] args)
    {
        var options = CommandOptions.Parse(args);
        var tasks = _store.Load();

        var filtered = tasks.AsEnumerable();

        if (!options.Has("all"))
        {
            filtered = filtered.Where(task => !task.IsDone);
        }

        if (options.Has("today"))
        {
            filtered = filtered.Where(task => task.DueDate == DateOnly.FromDateTime(DateTime.Today));
        }

        if (options.Has("overdue"))
        {
            var today = DateOnly.FromDateTime(DateTime.Today);
            filtered = filtered.Where(task => task.DueDate is not null && task.DueDate < today && !task.IsDone);
        }

        var rows = filtered
            .OrderBy(task => task.IsDone)
            .ThenBy(task => task.DueDate is null)
            .ThenBy(task => task.DueDate)
            .ThenByDescending(task => task.Priority)
            .ThenBy(task => task.Id)
            .ToList();

        if (rows.Count == 0)
        {
            Console.WriteLine("No tasks found.");
            return 0;
        }

        Console.WriteLine("ID  Status  Priority  Due         Title");
        Console.WriteLine("--  ------  --------  ----------  -----");

        foreach (var task in rows)
        {
            var status = task.IsDone ? "done" : "open";
            var due = task.DueDate?.ToString("yyyy-MM-dd") ?? "-";
            Console.WriteLine($"{task.Id,-2}  {status,-6}  {task.Priority,-8}  {due,-10}  {task.Title}");
        }

        return 0;
    }

    private int MarkDone(string[] args)
    {
        var id = ParseRequiredId(args, "done");
        var tasks = _store.Load();
        var task = FindTask(tasks, id);

        if (task.IsDone)
        {
            Console.WriteLine($"#{task.Id} was already done.");
            return 0;
        }

        task.CompletedAt = DateTimeOffset.Now;
        _store.Save(tasks);

        Console.WriteLine($"Completed #{task.Id}: {task.Title}");
        return 0;
    }

    private int Remove(string[] args)
    {
        var id = ParseRequiredId(args, "remove");
        var tasks = _store.Load();
        var task = FindTask(tasks, id);

        tasks.Remove(task);
        _store.Save(tasks);

        Console.WriteLine($"Removed #{task.Id}: {task.Title}");
        return 0;
    }

    private int Stats()
    {
        var tasks = _store.Load();
        var today = DateOnly.FromDateTime(DateTime.Today);
        var open = tasks.Count(task => !task.IsDone);
        var done = tasks.Count(task => task.IsDone);
        var overdue = tasks.Count(task => !task.IsDone && task.DueDate is not null && task.DueDate < today);
        var dueToday = tasks.Count(task => !task.IsDone && task.DueDate == today);

        Console.WriteLine($"Open:      {open}");
        Console.WriteLine($"Done:      {done}");
        Console.WriteLine($"Due today: {dueToday}");
        Console.WriteLine($"Overdue:   {overdue}");
        Console.WriteLine($"Data file: {TaskStorePaths.DefaultPath}");
        return 0;
    }

    private static int Fail(string message)
    {
        Console.Error.WriteLine($"Error: {message}");
        return 1;
    }

    private static bool IsHelp(string value)
    {
        return value is "help" or "-h" or "--help";
    }

    private static DateOnly ParseDate(string value)
    {
        if (DateOnly.TryParse(value, out var date))
        {
            return date;
        }

        throw new TaskPilotException("Due date must be a valid date such as 2026-07-15.");
    }

    private static int ParseRequiredId(string[] args, string command)
    {
        if (args.Length == 0 || !int.TryParse(args[0], out var id) || id <= 0)
        {
            throw new TaskPilotException($"{command} needs a positive task id.");
        }

        return id;
    }

    private static WorkTask FindTask(List<WorkTask> tasks, int id)
    {
        return tasks.FirstOrDefault(task => task.Id == id)
            ?? throw new TaskPilotException($"Task #{id} was not found.");
    }

    private static int NextId(IReadOnlyCollection<WorkTask> tasks)
    {
        return tasks.Count == 0 ? 1 : tasks.Max(task => task.Id) + 1;
    }

    private static void PrintHelp()
    {
        Console.WriteLine("""
        TaskPilot - small file-backed task tracker

        Usage:
          taskpilot add "Ship report" --due 2026-07-15 --priority high
          taskpilot list [--all] [--today] [--overdue]
          taskpilot done <id>
          taskpilot remove <id>
          taskpilot stats

        Priorities: low, medium, high
        """);
    }
}

internal interface ITaskStore
{
    List<WorkTask> Load();
    void Save(List<WorkTask> tasks);
}

internal sealed class JsonTaskStore : ITaskStore
{
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        WriteIndented = true,
        Converters = { new JsonStringEnumConverter() }
    };

    private readonly string _path;

    public JsonTaskStore(string path)
    {
        _path = path;
    }

    public List<WorkTask> Load()
    {
        if (!File.Exists(_path))
        {
            return [];
        }

        var json = File.ReadAllText(_path);
        return JsonSerializer.Deserialize<List<WorkTask>>(json, JsonOptions) ?? [];
    }

    public void Save(List<WorkTask> tasks)
    {
        var directory = Path.GetDirectoryName(_path);

        if (!string.IsNullOrWhiteSpace(directory))
        {
            Directory.CreateDirectory(directory);
        }

        File.WriteAllText(_path, JsonSerializer.Serialize(tasks, JsonOptions));
    }
}

internal static class TaskStorePaths
{
    public static string DefaultPath
    {
        get
        {
            var overridePath = Environment.GetEnvironmentVariable("TASKPILOT_DATA_FILE");

            if (!string.IsNullOrWhiteSpace(overridePath))
            {
                return overridePath;
            }

            var dataDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);

            if (string.IsNullOrWhiteSpace(dataDirectory))
            {
                dataDirectory = Environment.CurrentDirectory;
            }

            return Path.Combine(dataDirectory, "TaskPilot", "tasks.json");
        }
    }
}

internal sealed class CommandOptions
{
    private readonly Dictionary<string, string?> _options;

    private CommandOptions(Dictionary<string, string?> options, string positionalText)
    {
        _options = options;
        PositionalText = positionalText;
    }

    public string PositionalText { get; }

    public static CommandOptions Parse(string[] args)
    {
        var options = new Dictionary<string, string?>(StringComparer.OrdinalIgnoreCase);
        var positional = new List<string>();

        for (var i = 0; i < args.Length; i++)
        {
            var value = args[i];

            if (!value.StartsWith("-", StringComparison.Ordinal))
            {
                positional.Add(value);
                continue;
            }

            var key = value.StartsWith("--", StringComparison.Ordinal)
                ? value[2..]
                : value[1..];

            if (string.IsNullOrWhiteSpace(key))
            {
                throw new TaskPilotException("Option names cannot be empty.");
            }

            if (i + 1 < args.Length && !args[i + 1].StartsWith("--", StringComparison.Ordinal))
            {
                options[key] = args[++i];
            }
            else
            {
                options[key] = null;
            }
        }

        return new CommandOptions(options, string.Join(" ", positional));
    }

    public bool Has(string name)
    {
        return _options.ContainsKey(name);
    }

    public string? Get(string name)
    {
        return _options.GetValueOrDefault(name);
    }

    public string RequireValue(string name)
    {
        return _options.GetValueOrDefault(name)
            ?? throw new TaskPilotException($"--{name} needs a value.");
    }
}

internal sealed class WorkTask
{
    public int Id { get; set; }
    public required string Title { get; set; }
    public TaskPriority Priority { get; set; } = TaskPriority.Medium;
    public DateOnly? DueDate { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public DateTimeOffset? CompletedAt { get; set; }

    public bool IsDone => CompletedAt is not null;
}

internal enum TaskPriority
{
    Low = 0,
    Medium = 1,
    High = 2
}

internal sealed class TaskPilotException : Exception
{
    public TaskPilotException(string message)
        : base(message)
    {
    }
}