easydone 0.2.0__py3-none-any.whl

easydone/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    # use the distribution name from pyproject 'project.name' (make sure they match)
+    __version__ = version("easydone-task-tracker")
+except PackageNotFoundError:
+    # Package isn't installed (dev environment). Optional fallback:
+    __version__ = "0.0.0+dev"

easydone/__main__.py

@@ -0,0 +1,25 @@
+from .cli import Parser
+from .logic import TasksManager
+from .storage import JSONHandler
+from .format import describe_load_result, report_backup
+
+def main() -> None:
+    # JSONHandler instance for load/save in .json.
+    handler = JSONHandler()
+    load_result = handler.load()
+    describe_load_result(load_result)
+    
+    # TasksManager instance based on tasks loaded
+    manager = TasksManager(tasks_from_file=load_result.tasks)
+    
+    # Parser instance for cli interface and argumments
+    cli = Parser(manager)
+    mutated = cli.start_parsing()
+    
+    # save tasks before exiting only if mutated status
+    if mutated:
+        backup_result = handler.save(manager.tasks)
+        report_backup(backup_result)
+
+if __name__ == "__main__":
+    main()

easydone/cli.py

@@ -0,0 +1,155 @@
+from argparse import ArgumentParser, Namespace, SUPPRESS
+from .logic import TasksManager
+from .format import print_table
+from . import __version__
+
+SUPPORTED_STATUS = ["not-done", "done", "in-progress"]
+SUPPORTED_PRIORITIES = ["low", "normal", "high", "urgent"]
+
+class Parser():
+    """ A class to manage all the argument parser and command features. """
+    
+    def __init__(self, manager: TasksManager) -> None:
+        """Initialize the CLIApp attributes"""
+        if not isinstance (manager, TasksManager):
+            raise TypeError()
+            
+        self.tasks_manager = manager
+        self.build_parser()
+    
+    def build_parser(self) -> None:
+        """ Create the main parser and sub-commands. """
+        description = "Simple and powerfull task tracker. Helps you manage your to-do list directly from the terminal."
+        self.main_parser = ArgumentParser(
+            prog = "EasyDone", description = description, allow_abbrev = False,
+            epilog = "Thanks for using %(prog)s! :)\nAll feedback is appreciated.", )
+        
+        # Show the current version running.
+        self.main_parser.add_argument(
+            '-v', '--version', help='Display app version.', action="version",
+            version="%(prog)s " + __version__)
+        
+        # Sub-commands parser
+        sub_pars = self.main_parser.add_subparsers(title="actions")
+        
+        # 'NEW' command
+        # ====================
+        
+        # Create parser for 'new' command
+        new_pars = sub_pars.add_parser("new", help="Create a new task")
+        new_pars.add_argument(
+            "description", type=str, 
+            help="Description of the task to be added.")
+        
+        # optional flag for indicating initial status
+        new_pars.add_argument(
+            "-s", "--status", type=str, 
+            help="Optional initial status: defaults to 'not-done'.",
+            choices=SUPPORTED_STATUS, default=SUPPORTED_STATUS[0])
+        
+        # optional flag for indicating initial priority
+        new_pars.add_argument(
+            "-p", "--priority", type=str, 
+            help="Optional priority: defaults to 'low'.",
+            choices=SUPPORTED_PRIORITIES, default=SUPPORTED_PRIORITIES[0])
+        
+        # assign 'new' method from TasksManager to func attr of the Namespace returned by parser
+        new_pars.set_defaults(func=self.tasks_manager.new)
+        
+        # 'UPDATE' command
+        # ====================
+        update_pars = sub_pars.add_parser("update", help="Update a task.", argument_default=SUPPRESS)
+        
+        update_pars.add_argument(
+            "id", type=str, 
+            help="ID of the task to be updated.")
+        
+        update_pars.add_argument(
+            "-d", "--description", metavar="new-description", type=str, 
+            help="Update description.")
+        
+        update_pars.add_argument(
+            "-p", "--priority", metavar="new-priority",
+            type=str, help="Update priority.")
+
+        update_pars.set_defaults(func=self.tasks_manager.update)
+        
+        # 'MARK' command
+        # ====================
+        mark_pars = sub_pars.add_parser("mark", help="Mark a task with a new status.")
+        
+        mark_pars.add_argument(
+            "id", type=str, 
+            help="ID of the task to be marked.")
+        
+        mark_pars.add_argument(
+            "new_status", type=str, 
+            help="The new status for the task.",
+            choices=SUPPORTED_STATUS)
+        
+        mark_pars.set_defaults(func=self.tasks_manager.mark)
+        
+        # 'DELETE' command
+        # ====================
+        del_pars = sub_pars.add_parser("delete", help="Deletes a task.")
+        
+        del_pars.add_argument(
+            "ids", type=str, nargs='+', metavar='id',
+            help="IDs of the tasks to be deleted.")
+        
+        del_pars.add_argument(
+            "-f", "--forced", action="store_true",
+            help="If not used, the user will be prompted for confirmation.")
+        
+        del_pars.set_defaults(func=self.tasks_manager.delete)
+        
+        # 'LIST' command
+        # ====================
+        list_pars = sub_pars.add_parser("list", help="List all tasks.")
+        
+        list_pars.add_argument(
+            "-s", "--status", type=str, 
+            help="To list all tasks with a given status.",
+            choices=SUPPORTED_STATUS, default=None)
+
+        list_pars.add_argument(
+            "-p", "--priority", type=str, 
+            help="To list all tasks with a given priority.",
+            choices=SUPPORTED_PRIORITIES, default=None)
+    
+        list_pars.add_argument(
+            "--no-dates", action="store_true",
+            help="Not ouput dates.",)
+        
+        list_pars.set_defaults(func=self.tasks_manager.list)
+
+    def start_parsing(self) -> bool:
+        """ Parses the arguments passed. Returns true if some command mutated state of any task. """
+        args: Namespace
+        try:
+            args = self.main_parser.parse_args()
+        except ValueError as exc:
+            self.main_parser.error(str(exc))
+            return False
+
+        if getattr(args, 'func', None) == self.tasks_manager.list:
+            filtered_ids = args.func(args)
+            print_table(self.tasks_manager.tasks, filtered_ids, no_dates=args.no_dates) 
+            return False
+    
+        if getattr(args, 'func', None) == self.tasks_manager.update:
+            has_update_target = hasattr(args, 'description') or hasattr(args, 'priority')
+            if not has_update_target:
+                self.main_parser.error("the update command requires at least one field change: --description or --priority")
+
+        if not hasattr(args, 'func'):
+            # in case user invokes the program without arguments like:
+            # >>> easydone
+            self.main_parser.print_help()
+            return False
+        else:
+            try:
+                args.func(args)
+                return True
+            except (ValueError, KeyError, AttributeError, TypeError) as exc:
+                self.main_parser.error(str(exc))

easydone/format.py

@@ -0,0 +1,164 @@
+"""Output formatting helpers.
+
+This module centralizes all user-facing presentation logic so the CLI
+parsing and task-management logic remain separate. The primary function
+`print_table` prints a table of tasks. It attempts to use Rich for nicely
+styled tables and colors; when Rich is not available it falls back to a
+plain-text table so the application remains dependency-light.
+"""
+
+from typing import Dict, List, Any
+from .storage import LoadingResult, LoadStatus, CURRENT_SCHEMA_VERSION
+from . import __version__
+
+try:
+    # Import the specific Rich helpers we need. If they are not available,
+    # the import will raise and the code will fall back to plain text.
+    from rich.console import Console
+    from rich.table import Table
+    from rich.text import Text
+    RICH_AVAILABLE = True
+except Exception:
+    RICH_AVAILABLE = False
+
+
+def _plain_print(tasks: Dict[str, dict], 
+                ids: List[str], 
+                no_dates: bool = False
+                ) -> None:
+    """Plain-text fallback used when Rich is unavailable."""
+    print("====================================")
+    print("EasyDone: Task-Tracker")
+    print("====================================")
+    for task_id in ids:
+        # Use .get() so older or partially missing task dictionaries still print.
+        task = tasks[task_id]
+        desc = task.get('description', 'unknown')
+        prior = task.get('priority', 'unknown')
+        stat = task.get('status', 'unknown')
+        create = '[' + str(task.get('created-at', 'unknown')) + ']' if not no_dates else "" 
+        update = '[' + str(task.get('updated-at', 'unknown')) + ']' if not no_dates else "" 
+        print(f"ID: {task_id} \"{desc}\" [{prior}] [{stat}] {create} {update}")
+    print("====================================")
+
+def print_table(tasks: Dict[str, dict], 
+                ids: List[str], 
+                no_dates: bool = False
+                ) -> None:
+    """Print a tasks table using Rich when available, otherwise use plain text.
+
+    Columns: ID, Description, Priority, Status, Created, Updated.
+    The status and priority values are highlighted in color when Rich is present.
+    """
+    if not ids:
+        print("No tasks to show.")
+        return
+
+    if not RICH_AVAILABLE:
+        _plain_print(tasks, ids, no_dates=no_dates)
+        return
+
+    # Build a Rich table in the presentation layer. This keeps formatting and
+    # colors separated from task logic and CLI argument parsing.
+    console = Console() # type: ignore
+    table = Table(show_header=True, header_style="bold magenta") # type: ignore
+    table.add_column("ID", style="dim", no_wrap=True)
+    table.add_column("Description")
+    table.add_column("Priority", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    if not no_dates:
+        table.add_column("Created", no_wrap=True)
+        table.add_column("Updated", no_wrap=True)
+
+    priority_styles = {
+        "low": "dim",
+        "normal": "",
+        "high": "bold yellow",
+        "urgent": "bold red",
+    }
+    status_styles = {
+        "not-done": "yellow",
+        "in-progress": "cyan",
+        "done": "green",
+    }
+
+    for task_id in ids:
+        task = tasks[task_id]
+        desc = task.get('description', 'unknown')
+        prior = task.get('priority', 'unknown')
+        stat = task.get('status', 'unknown')
+        create: str
+        update: str
+        if not no_dates:
+            create = task.get('created-at', 'unknown')
+            update = task.get('updated-at', 'unknown')
+            update = '-' if update is None else update
+            table.add_row(
+                task_id,
+                Text(desc, overflow='ellipsis'),    # type: ignore
+                Text(prior, style=priority_styles.get(prior, "")),  # type: ignore
+                Text(stat, style=status_styles.get(stat, "")),  # type: ignore
+                create,
+                update,
+            )
+        else:
+            table.add_row(
+                task_id,
+                Text(desc, overflow='ellipsis'),    # type: ignore
+                Text(prior, style=priority_styles.get(prior, "")),  # type: ignore
+                Text(stat, style=status_styles.get(stat, "")),  # type: ignore
+            )
+            
+    console.print(table)
+
+def describe_load_result(result: LoadingResult) -> None:
+    msg = ""
+    if result.status is LoadStatus.MISSING:
+        msg = f"{result.file_path} does not exist. Starting with an empty task list."
+
+    if result.status is LoadStatus.CORRUPTED:
+        msg = f"Warning: {result.file_path} is unreadable or malformed."
+        if result.backup_path:
+            msg += f" A copy was saved to {result.backup_path} for review."
+        else:
+            msg += f" Unable to save corrupted file: ({result.backup_exception})"
+
+    lines = []
+    if result.schema_mismatch:
+        lines.append(
+            f"Found schema version {result.found_schema_version} "
+            f"(app expects {CURRENT_SCHEMA_VERSION})"
+        )
+    if result.app_mismatch:
+        lines.append(
+            f"written by EasyDone {result.found_app_version} "
+            f"(running Easydone {__version__})"
+            )
+
+    if lines:
+        msg = "Warning: " + " and ".join(lines) + "."
+
+    if msg:
+        style = 'yellow'
+    else:
+        style = 'green'
+        msg = "Tasks loaded successfully."
+    
+    if RICH_AVAILABLE:
+        console = Console()                     # type: ignore
+        console.print(Text(msg, style=style))   # type: ignore
+    else:
+        print(msg)
+
+def report_backup(backup_result: dict[str, Any]):
+    if backup_result['backup_path']:
+        text = "Backup succesfully done"
+        style = 'green'
+    else:
+        text = f"Warning: Couldn't backup ({backup_result['backup_exception']})"
+        style = 'yellow'
+    if RICH_AVAILABLE:
+        console = Console()     # type: ignore
+        console.print(Text(text=text, style=style)) # type: ignore
+    else:
+        print(text)

easydone/logic.py

@@ -0,0 +1,94 @@
+from argparse import Namespace
+from random import randint
+from datetime import datetime
+
+class TasksManager():
+    """ A class to manage all tasks logic. """
+    def __init__(self, tasks_from_file:dict[str, dict]):
+        self.tasks = tasks_from_file # internal dict for tracking tasks
+        self.ID_SIZE = 3 # number of digits to generate for an ID
+    
+    def new(self, args: Namespace):
+        """ Create a new task. """
+        self.tasks[self.task_id()] = {
+            "description": args.description, 
+            "status": args.status,
+            "priority": args.priority,
+            "created-at": str(datetime.now()).split(" ")[0],
+            "updated-at": None
+            }
+
+    def update(self, args: Namespace):
+        """ Updates a task. """
+        if args.id not in self.tasks:
+            raise KeyError("Unexistent task")
+
+        task = self.tasks[args.id]
+        if hasattr(args, 'description') and args.description == task['description']:
+            raise ValueError("New description must be different from the current description.")
+
+        if hasattr(args, 'priority') and args.priority == task['priority']:
+            raise ValueError("New priority must be different from the current priority.")
+
+        if hasattr(args, 'description'):
+            task['description'] = args.description
+
+        if hasattr(args, 'priority'):
+            task['priority'] = args.priority
+
+        task['updated-at'] = str(datetime.now()).split(" ")[0]
+    
+    def mark(self, args: Namespace):
+        """Marking task as done, not done or in progress"""
+        if (id := args.id) not in self.tasks:
+            raise KeyError("Unexistent task")
+
+        self.tasks[args.id]["status"] = args.new_status
+        self.tasks[args.id]["updated-at"] = str(datetime.now()).split(" ")[0]
+    
+    def delete(self, args: Namespace):
+        """ Deletes a list of tasks. """
+        for id in args.ids:
+            if id not in self.tasks: 
+                raise KeyError(f"Unexistent task ({id})")
+        
+        for id in set(args.ids):
+            if not args.forced:
+                if not yes_no(f"are you sure u want to delete the task {id}:\"{self.tasks[id]['description']}\" ?"):
+                    continue
+        
+            self.tasks.pop(id)
+            
+    def list(self, args: Namespace) -> list[str]:
+        """ Shows all tasks. Filtered according to args.status and args.priority. """
+        ids = []
+        
+        s_filt = args.status
+        p_filt = args.priority
+        for key, value in self.tasks.items():
+            # check if task passes filters
+            if (s_filt is None or value['status'] == s_filt) and (p_filt is None or value['priority'] == p_filt):
+                ids.append(key)
+        
+        return ids
+    
+    def task_id(self) -> str:
+        """ Returns a random id, formed by digits, the number of digits is determined by self.ID_SIZE"""
+        id = None
+        # keeps generating until gets an id that's not already present.
+        while id is None or id in self.tasks:
+            id = ""
+            for _ in range(self.ID_SIZE):
+                id += str(randint(0, 9))
+        return id
+
+def yes_no(prompt: str) -> bool:
+    """Asks the user a yes/no question and returns True for yes and False for no."""
+    while True:
+        response = input(prompt + " (y/n): ").strip().lower()
+        if response in ['y', 'yes']:
+            return True
+        elif response in ['n', 'no']:
+            return False
+        else:
+            print("Invalid input. Please enter 'y' or 'n'.")

easydone/storage.py

@@ -0,0 +1,178 @@
+import json
+import os
+import sys
+import shutil
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, NamedTuple, Any
+from enum import Enum
+
+from . import __version__
+
+CURRENT_SCHEMA_VERSION = 1
+
+def default_storage_path() -> Path:
+    """Return a stable, user-scoped path for EasyDone task data.
+
+    Behavior and rationale:
+    - If the EASYDONE_DATA_FILE environment variable is set, use it. This allows CI, tests, and advanced users to redirect storage to a custom file.
+    - Otherwise choose a platform-appropriate per-user application data directory:
+        * Windows: %APPDATA% (e.g. C:/Users/<user>/AppData/Roaming)
+        * macOS: ~/Library/Application Support
+        * Linux/other: XDG_DATA_HOME or ~/.local/share as a fallback
+    - The final file is placed under <base>/easydone/tasks.json so the data is predictable and independent of the current working directory.
+    """
+    # Allow an explicit override for testing or advanced usage. Expand ~ if present.
+    custom_path = os.environ.get("EASYDONE_DATA_FILE")
+    if custom_path:
+        return Path(custom_path).expanduser()
+
+    # Select a sensible base directory depending on the platform. Using a
+    # per-user application data directory avoids scattering data files across
+    # arbitrary working directories and follows common OS conventions.
+    if os.name == "nt":
+        # On Windows prefer APPDATA; fall back to a reasonable user path when
+        # APPDATA is not available in the environment.
+        base_dir = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+    elif sys.platform == "darwin":
+        # macOS convention for app data
+        base_dir = Path.home() / "Library" / "Application Support"
+    else:
+        # Follow XDG Base Directory Specification when possible, otherwise use
+        # ~/.local/share as a conventional fallback for Linux and other Unix-like OSes.
+        base_dir = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+
+    # Keep the final data file path deterministic and easy to locate.
+    return base_dir / "easydone" / "tasks.json"
+
+class LoadStatus(Enum):
+    OK = "ok"
+    MISSING = "missing"
+    CORRUPTED = "corrupted"
+
+class LoadingResult(NamedTuple):
+    tasks: dict[str, dict] = {}
+    status: LoadStatus = LoadStatus.OK
+    file_path: Optional[Path] = None
+    backup_path: Optional[Path] = None
+    backup_exception: Optional[Exception] = None
+    found_schema_version: Optional[int] = None
+    found_app_version: Optional[str] = None
+    schema_mismatch: bool = False
+    app_mismatch: bool = False
+
+class JSONHandler():
+    def __init__(self, json_file: Optional[str] = None):
+        """
+        Initialize a storage handler with a stable absolute data file path.
+        """
+        self.app_version = __version__
+        self.json_file = Path(json_file).expanduser() if json_file else default_storage_path()
+
+    def _quarantine_path(self) -> Path:
+        """ Returns a quarantine path. """
+        file_path = self.json_file
+        timestamp = datetime.now().strftime("%Y%m%dT%H%M%S")
+        quarantine_path = file_path.with_name(
+            f"{file_path.stem}.corrupted-{timestamp}{file_path.suffix}"
+        )
+        return quarantine_path
+    
+    def _backup_path(self) -> Path:
+        """ Returns a backup path. """
+        file_path = self.json_file
+        backup_path = file_path.with_suffix(file_path.suffix + '.bak')
+        return backup_path
+    
+    def _backup(self, quarantine=False) -> dict[str, Any]:
+        """
+        Backups a file, returns the backup path if succeed, else returns the exception raised.
+        """
+        try:
+            file_path = self.json_file
+            backup_path = self._quarantine_path() if quarantine else self._backup_path()
+            shutil.copy2(file_path, backup_path)
+            return {"backup_path": backup_path, "backup_exception": None}
+        except (PermissionError, MemoryError, FileNotFoundError) as exc:
+            # remove backup file if any error happened
+            backup_path.unlink(missing_ok=True) # type: ignore
+            return {"backup_path": None, "backup_exception": exc}
+
+    def load(self) -> LoadingResult:
+        """Load tasks from the JSON file."""
+        # load file's content into payload or handle exception
+        try:
+            with open(self.json_file, 'r', encoding='utf-8') as file:
+                payload = json.load(file)
+        except FileNotFoundError:
+            return LoadingResult(
+                tasks={}, status=LoadStatus.MISSING, file_path=self.json_file
+                )
+        except (json.JSONDecodeError, OSError, TypeError, ValueError):
+            backup_result = self._backup(quarantine=True)
+            return LoadingResult(
+                tasks={}, status=LoadStatus.CORRUPTED, 
+                file_path=self.json_file, **backup_result
+                )
+
+        # unexpected format of content loaded
+        if not isinstance(payload, dict):
+            backup_result = self._backup(quarantine=True)
+            return LoadingResult(
+                tasks={}, status=LoadStatus.CORRUPTED, 
+                file_path=self.json_file, **backup_result
+                )
+
+        # try to get metadata from dict loaded
+        tasks = payload.get("tasks")
+        schema_version = payload.get("schema_version", 0)
+        app_version = payload.get("app_version", "unknown")
+
+        # unexpected format of tasks
+        if not isinstance(tasks, dict):
+            backup_result = self._backup(quarantine=True)
+            return LoadingResult(
+                tasks={}, status=LoadStatus.CORRUPTED, 
+                file_path=self.json_file, **backup_result
+                )
+
+        return LoadingResult(
+            tasks=tasks, status=LoadStatus.OK, file_path=self.json_file,
+            found_schema_version = schema_version,
+            found_app_version = app_version,
+            schema_mismatch = schema_version != CURRENT_SCHEMA_VERSION,
+            app_mismatch = app_version != self.app_version
+            )
+
+    def save(self, tasks: dict[str, dict]) -> dict[str, Any]:
+        """Persist tasks with metadata so upgrades can be reviewed safely. Returns a dict containing backup results."""
+        if not isinstance(tasks, dict):
+            raise TypeError("tasks must be a dictionary of task records")
+
+        self.json_file.parent.mkdir(parents=True, exist_ok=True)
+
+        payload = {
+            "schema_version": CURRENT_SCHEMA_VERSION,
+            "app_version": self.app_version,
+            "saved_at": datetime.now().date().isoformat(),
+            "tasks": tasks,
+        }
+
+        # Keep the last known-good file before touching it.
+        backup_result = self._backup()
+    
+        # Write to a temp file in the SAME directory (matters: os.replace across
+        # filesystems isn't atomic), then swap it in as one step.
+        fd, tmp_path = tempfile.mkstemp(
+            dir=self.json_file.parent, prefix=".tasks-", suffix=".tmp"
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as tmp_file:
+                json.dump(payload, tmp_file, indent=4)
+            os.replace(tmp_path, self.json_file)  # atomic on POSIX AND Windows
+        except Exception:
+            os.unlink(tmp_path)  # don't leave stray .tmp files on failure
+            raise
+        
+        return backup_result

easydone-0.2.0.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: easydone
+Version: 0.2.0
+Summary: A CLI app made with python for easy tasks management.
+Author-email: Pedro Alberto Rosquete Ares <rosquetearespedro06@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Pedro Alberto Rosquete Ares
+        
+        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.
+        
+Project-URL: Documentation, https://github.com/prares-dev/easydone.git
+Project-URL: Homepage, https://github.com/prares-dev/easydone.git
+Project-URL: Repository, https://github.com/prares-dev/easydone.git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# easydone - Task Tracker App
+
+> A focused command-line task manager for turning a messy to-do list into a clear next action.
+
+easydone is a lightweight Python CLI for creating, updating, completing, deleting, and filtering tasks directly from your terminal. Tasks are saved as readable JSON, and the storage layer now includes **automatic backups, corruption quarantine, and atomic writes** to keep your data safe.
+
+## Why easydone?
+
+- Fast terminal-first workflow  
+- Statuses for work in motion: `not-done`, `in-progress`, and `done`  
+- Four priority levels: `low`, `normal`, `high`, and `urgent`  
+- Filter tasks by status, priority, or both  
+- Human-readable JSON storage with no database setup  
+- **Bulletproof data handling**: atomic writes, automatic `.bak` backups, and quarantine of corrupted files  
+- Pretty terminal output with [Rich](https://github.com/Textualize/rich) (falls back to plain text if unavailable)
+
+## Project Structure
+
+```text
+easydone/
+├── easydone/
+│   ├── __init__.py   # Package metadata (version, etc.)
+│   ├── __main__.py   # Application entry point
+│   ├── cli.py        # Argument parser and command dispatch
+│   ├── logic.py      # Task-management operations
+│   ├── storage.py    # JSON loading/saving with backup & quarantine
+│   └── format.py     # Output formatting (Rich / plain)
+├── tests/
+│   ├── test_cli.py
+│   ├── test_logic.py
+│   ├── test_storage.py
+│   └── test_format.py
+├── LICENSE
+├── pyproject.toml    # Packaging and pytest configuration
+└── README.md
+```
+
+## Quick Start
+
+### Requirements
+
+- Python 3.9 or newer  
+- Windows PowerShell, macOS, or Linux terminal
+
+From the project root, create a virtual environment and install `easydone` in editable mode:
+
+```powershell
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+py -m pip install -e .
+```
+
+On macOS or Linux:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .
+```
+
+Or install directly from PyPI:
+
+```powershell
+py -m pip install easydone
+```
+
+You can now run the application:
+
+```shell
+easydone
+```
+
+To see all available commands:
+
+```shell
+easydone --help
+```
+
+## Everyday Workflow
+
+Create a task:
+
+```shell
+easydone new "Read a book"
+```
+
+Create a task with a status and priority:
+
+```shell
+easydone new "Finish project report" --status in-progress --priority high
+```
+
+List everything:
+
+```shell
+easydone list
+```
+
+Focus on urgent unfinished work:
+
+```shell
+easydone list --status not-done --priority urgent
+```
+
+Mark a task as complete:
+
+```shell
+easydone mark 123 done
+```
+
+## Command Reference
+
+### `new`
+
+Create a task. The description is required.
+
+```shell
+easydone new DESCRIPTION [--status STATUS] [--priority PRIORITY]
+```
+
+Options:
+
+- `-s`, `--status`: `not-done`, `done`, or `in-progress`; defaults to `not-done`
+- `-p`, `--priority`: `low`, `normal`, `high`, or `urgent`; defaults to `low`
+
+### `update`
+
+Change the description and/or priority of an existing task.  
+The `--priority` option now validates against the four allowed values.
+
+```shell
+easydone update TASK_ID [--description NEW_DESCRIPTION] [--priority NEW_PRIORITY]
+```
+
+Examples:
+
+```shell
+easydone update 123 --description "Read a novel"
+easydone update 123 --priority high
+```
+
+### `mark`
+
+Change the status of an existing task.
+
+```shell
+easydone mark TASK_ID new-status
+```
+
+### `delete`
+
+Delete one or more existing tasks. easydone tasks for confirmation for each ID unless `-f` or `--forced` is used.
+
+```shell
+easydone delete TASK_ID [TASK_ID ...]
+easydone delete TASK_ID [TASK_ID ...] --forced
+```
+
+If you supply multiple IDs, all of them are validated before any deletion occurs. If any ID is invalid, the entire operation is aborted and no tasks are removed.
+
+### `list`
+
+List all tasks or filter them by status and priority. You can omit dates with the `--no-dates` option.
+
+```shell
+easydone list [--status STATUS] [--priority PRIORITY] [--no-dates]
+```
+
+When both filters are supplied, a task must match both of them.
+
+## Data Storage
+
+`easydone` stores task data in a user‑scoped application directory so it does not depend on where the command is launched from.
+
+- **Windows**: `%APPDATA%\easydone\tasks.json`
+- **macOS**: `~/Library/Application Support/easydone/tasks.json`
+- **Linux**: `~/.local/share/easydone/tasks.json`
+
+The app writes a small metadata wrapper with the file schema version and the version of easydone that saved it. This makes future upgrades safer and compatibility warnings explicit.
+
+```json
+{
+    "schema_version": 1,
+    "app_version": "0.2.0",
+    "saved_at": "2026-08-28",
+    "tasks": {
+        "123": {
+            "description": "Finish project report",
+            "status": "in-progress",
+            "priority": "high",
+            "created-at": "2026-08-28",
+            "updated-at": null
+        }
+    }
+}
+```
+
+### Safety & Recovery
+
+`easydone` now protects your data in three ways:
+
+1. **Atomic writes**: Every save writes to a temporary file first, then swaps it atomically. A crash mid‑write never leaves a half‑written file.
+2. **Automatic backups**: Before every save, the current `tasks.json` is copied to `tasks.json.bak`. If something goes wrong, you can restore from this backup.
+3. **Corruption quarantine**: If easydone encounters an unreadable or malformed file on load, it copies that file to `tasks.corrupted-<timestamp>.json` instead of discarding it. You can inspect the quarantined file and recover data manually.
+
+If an older file is found (different schema or app version), `easydone` still loads it but prints a detailed warning so you can review the data before saving again.
+
+## Development
+
+Install the development dependency group:
+
+```shell
+py -m pip install -e ".[dev]"
+```
+
+Run the complete test suite:
+
+```shell
+py -m pytest
+```
+
+Run a specific test module:
+
+```shell
+py -m pytest tests/logic_test.py
+py -m pytest tests/storage_test.py
+py -m pytest tests/format_test.py
+```
+
+## License
+
+This project is available under the license in [LICENSE](LICENSE).

easydone-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+easydone/__init__.py,sha256=jfQbh7XOfARzUhtfwmWJ0n7_kINOSPZGPJpd-u6-55U,336
+easydone/__main__.py,sha256=_X3PblOW4riqT1E7Jk1hKfgn6_Kooon8OeoN3lIsVLU,780
+easydone/cli.py,sha256=IJbDOvjFrE37GeS5WY-UT20ZsZchzJuHzIdT_lSeI0I,6253
+easydone/format.py,sha256=BiR-SoN4OpweG_HTZfGTG3dDcQQ00HpsFtJFu35HCBE,6116
+easydone/logic.py,sha256=WpPl-UwTIN-1x0aZ1FR3-D6kn39XFqd0ameds7R6IZY,3656
+easydone/storage.py,sha256=9wKoy6PQ2Htb60drp_y2Sq2F7BO0sSJklF9lNORgwkg,7582
+easydone-0.2.0.dist-info/licenses/LICENSE,sha256=r6Bn3fQKU3hdDQE6nnYXNpI2sWnROJSE4BWlpRRNeh4,1105
+easydone-0.2.0.dist-info/METADATA,sha256=MakHe69sr7FMAPIOdtXg9Bc_-EiK9bVzU8mE1mw7RAY,8202
+easydone-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+easydone-0.2.0.dist-info/entry_points.txt,sha256=d9D0I3gq_ultiFP0U7czEj_k5EVkubxsST7ejbFTnoQ,52
+easydone-0.2.0.dist-info/top_level.txt,sha256=PR_U4pT1FjXHw5vP9d2sggbqPSnx-SS_IcvXv3g2LPQ,9
+easydone-0.2.0.dist-info/RECORD,,

easydone-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

easydone-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+easydone = easydone.__main__:main

easydone-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Alberto Rosquete Ares
+
+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.

easydone-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+easydone