taskninja 1.0.3 → 1.1.0

package/README.md

@@ -1,30 +1,27 @@
 # TaskNinja
 
-![TaskNinja Logo](https://via.placeholder.com/150?text=TaskNinja) <!-- Optional: Replace with actual logo if available -->
+**Version:** 1.1.0
+**Description:** A simple CLI To-Do Application to manage your tasks directly from the terminal. Includes colored tables, search, soft delete, undo, and interactive sort.
 
-A simple Command-Line Interface (CLI) application built with JavaScript for managing your to-do tasks. It allows users to add, list, update, and delete tasks interactively, with features like status tracking, priority levels, due dates, and descriptions. Tasks are stored in a local JSON file for persistence.
+---
 
-This project is designed for developers and users who prefer a lightweight, terminal-based task manager without the need for complex setups or databases.
+## Table of Contents
 
-## Features
+* [Installation](#installation)
+* [Running the CLI](#running-the-cli)
+* [Commands](#commands)
 
-- **Add Tasks**: Create new tasks with title, status (todo, in-progress, done), priority (low, medium, high), due date, and optional description.
-- **List Tasks**: View all tasks or filter by status in a tabular format.
-- **Update Tasks**: Change the status of existing tasks via interactive selection.
-- **Delete Tasks**: Remove tasks with confirmation to prevent accidental deletion.
-- **Persistent Storage**: Tasks are saved to a local `todos.json` file.
-- **Interactive Prompts**: Uses Inquirer for user-friendly input.
-- **Validation**: Ensures valid statuses, priorities, and date formats.
+  * [Add Task](#add-task)
+  * [List Tasks](#list-tasks)
+  * [Update Task](#update-task)
+  * [Delete Task](#delete-task)
+  * [Undo Delete Task](#undo-delete-task)
+  * [Search Tasks](#search-tasks)
+  * [Sort Tasks](#sort-tasks)
+* [Task Fields & Allowed Values](#task-fields--allowed-values)
+* [Examples](#examples)
 
-## Technologies Used
-
-- **Node.js**: Runtime environment.
-- **Commander**: For parsing command-line arguments and defining commands.
-- **Inquirer**: For interactive CLI prompts.
-- **fs/promises**: For asynchronous file system operations to handle task storage.
-- **ECMAScript Modules (ESM)**: Modern JavaScript module system.
-
-The application is written in pure JavaScript (ES6+), with no additional frameworks or databases required.
+---
 
 ## Installation
 
@@ -36,198 +33,350 @@ TaskNinja is published on npm as `taskninja`. Install it globally to use the CLI
 npm install -g taskninja
 ```
 
-After installation, you can run the CLI using the `dotask` command (as defined in `package.json`).
-
-### From Source
-
-1. Clone the repository:
-   ```bash
-   git clone https://github.com/yourusername/taskninja.git
-   cd taskninja
-   ```
-
-2. Install dependencies:
-   ```bash
-   npm install
-   ```
-
-3. Link the CLI globally (optional, for testing):
-   ```bash
-   npm link
-   ```
+or use it instantly with:
+
+```bash
+npx taskninja
+npx taskninja <command>
+```
+
+Clone the repository and install dependencies:
+
+```bash
+git clone <your-repo-url>
+cd taskninja
+npm install
+```
+
+---
+
+## Running the CLI
+
+You can run the CLI using either `node` or the bin aliases:
+
+```bash
+# Using node
+node app.js <command>
+
+# Using bin aliases
+dotask <command>
+taskninja <command>
+tn <command>
+```
+
+Replace `<command>` with any of the available commands: `add`, `list`, `update`, `delete`, `undo`, `search`, `sort`.
+
+---
+
+## Commands
 
-4. Run the application:
-   ```bash
-   npm start
-   ```
-   Or directly:
-   ```bash
-   node app.js
-   ```
+### 1. Add Task
 
-## Usage
+**Alias:** `a`
+**Description:** Add a new task interactively.
 
-Run the CLI with the `dotask` command (after global installation) or `node app.js` from the source.
+```bash
+tn a
+```
 
-### Commands
+**Prompts:**
 
-- **Add a Task**:
-  ```bash
-  dotask add
-  ```
-  - This will prompt you interactively for title, status, priority, due date, and description.
-  - Example output: "Task added successfully!"
+1. **Task Title:** Enter any text (cannot be empty).
 
-- **List Tasks**:
-  ```bash
-  dotask list
-  ```
-  - Lists all tasks in a table format.
-  - Optional filter by status: `dotask list --status todo` (or `-s todo`).
-  - Aliases: `dotask ls`.
+2. **Task Status:** Select from allowed values using arrows:
 
-- **Update a Task**:
-  ```bash
-  dotask update
-  ```
-  - Prompts to select a task by ID and update its status.
-  - Displays the updated task in a table.
-  - Aliases: `dotask up`.
+   * todo
+   * in-progress
+   * done
 
-- **Delete a Task**:
-  ```bash
-  dotask delete
-  ```
-  - Prompts to select a task by ID and confirm deletion.
-  - Aliases: `dotask del`.
+3. **Task Priority:** Select from allowed values:
 
-- **Help**:
-  ```bash
-  dotask --help
-  ```
-  - Shows all available commands and options.
+   * low
+   * medium
+   * high
 
-- **Version**:
-  ```bash
-  dotask --version
-  ```
-  - Displays the current version (1.0.0).
+4. **Due Date:** Enter in `YYYY-MM-DD` format. Invalid dates will show a validation error.
 
-### Examples
+5. **Description:** Optional text.
 
-1. Adding a task:
-   ```
-   dotask add
-   ```
-   - Follow prompts: Enter "Buy groceries" as title, select "todo" status, "medium" priority, "2024-12-31" due date, and "Milk, eggs, bread" as description.
+**Behavior:**
 
-2. Listing tasks filtered by status:
-   ```
-   dotask list -s in-progress
-   ```
+* Task is saved in `todos.json`.
+* Confirmation message: `Task added successfully!`
 
-3. Updating a task:
-   ```
-   dotask update
-   ```
-   - Select task ID from the list and choose new status (e.g., "done").
+---
 
-4. Deleting a task:
-   ```
-   dotask delete
-   ```
-   - Select task ID and confirm.
+### 2. List Tasks
 
-Tasks are stored in `./todos.json` relative to where the command is run. Ensure write permissions in the directory.
+**Alias:** `ls`
+**Description:** List all tasks, optionally filtered by status.
 
-## Configuration
+```bash
+tn ls
+tn ls --status todo
+```
 
-- **Task File**: Defaults to `./todos.json`. You can modify `TASKS_FILE` in `app.js` if needed.
-- **Statuses**: Limited to "todo", "in-progress", "done".
-- **Priorities**: Limited to "low", "medium", "high".
-- **Due Date Format**: YYYY-MM-DD (validated during input).
+**Behavior:**
 
-No external configuration files are required.
+* Displays tasks in a **colored table** using chalk:
 
-## Development
+| # | ID | Title | Status | Priority | DueDate | Description |
+| - | -- | ----- | ------ | -------- | ------- | ----------- |
+
+* Status colors: `todo` → blue, `in-progress` → yellow, `done` → green
+* Priority colors: `low` → green, `medium` → yellow, `high` → red
+
+---
+
+### 3. Update Task
+
+**Alias:** `up`
+**Description:** Update an existing task by selecting its ID.
 
-To run in development mode:
 ```bash
-npm run dev
+tn up
 ```
 
-This executes `node app.js` for quick testing.
+**Steps:**
+
+1. Select task by ID from a list.
+2. Confirm which fields to change (title, status, priority, due date, description).
+3. Enter new values where applicable.
+
+**Behavior:**
+
+* Only fields selected for change are updated.
+* Confirmation message: `Task updated successfully!`
+* Shows updated **colored task table**.
+
+---
+
+### 4. Delete Task
+
+**Alias:** `del`
+**Description:** Soft delete a task by selecting its ID.
+
+```bash
+tn del
+```
+
+**Steps:**
+
+1. Select task by ID from a list.
+2. Confirm deletion.
+
+**Behavior:**
+
+* Task is removed from `todos.json` **but saved in `deleted-todos.json`**.
+* Confirmation: `Task deleted successfully!`
+* You can restore it using the `undo` command.
+
+---
+
+### 5. Undo Delete Task
+
+**Alias:** `un`
+**Description:** Restore the last deleted task.
+
+```bash
+tn un
+```
+
+**Behavior:**
+
+* Restores the last deleted task from `deleted-todos.json`.
+* Confirmation: `Last deleted task restored successfully!, (Task name: taskName)`
+
+---
+
+Here’s the **Search Tasks** section in the README updated in English after your CLI changes:
+
+---
+
+### 6. Search Tasks
+
+**Alias:** `sr`
+**Description:** Search tasks by keyword in title or description.
+
+```bash
+# Search interactively
+tn search
+
+# Or search directly using --find
+tn search --find "meeting"
+```
+
+**Behavior:**
+
+* If you run `tn search` without a keyword, the CLI will ask you:
 
-### Scripts
+  1. Enter the keyword you want to search for.
+  2. Choose where to search: in the title, description, or both.
 
-- `npm start`: Runs the app.
-- `npm test`: Placeholder for tests (currently errors out; add tests as needed).
+* If you use `--find <keyword>` directly, the CLI will return all tasks containing that keyword in the title or description.
+
+**Example:**
+
+```bash
+tn search
+```
+
+```
+Enter the keyword you want to search for: meeting
+Where do you want to search? (Use arrow keys)
+1. title
+2. description
+3. both
+```
+
+```bash
+tn search --find "meeting"
+```
+
+┌─┬────┬────────────┬─────────────┬─────────┬────────────┬───────────────────┐
+│#│ ID │ Title      │ Status      │ Priority│ DueDate    │ Description       │
+├─┼────┼────────────┼─────────────┼─────────┼────────────┼───────────────────┤
+│1│ 3  │ Team meeting│ todo       │ medium  │ 2026-02-01 │ Discuss project   │
+└─┴────┴────────────┴─────────────┴─────────┴────────────┴───────────────────┘
+
+---
+
+### 7. Sort Tasks
+
+**Alias:** `so`
+**Description:** Sort tasks interactively by due date, priority, or status.
+
+```bash
+tn so
+```
+
+**Behavior:**
+
+* Prompts: `Sort tasks by:` → select from `dueDate`, `priority`, `status`.
+* Displays **sorted colored table**.
+* Can also pass `--by` option: `tn so --by priority`
+
+---
+
+## Task Fields & Allowed Values
+
+| Field       | Allowed Values / Description |
+| ----------- | ---------------------------- |
+| title       | Any non-empty string         |
+| status      | todo, in-progress, done      |
+| priority    | low, medium, high            |
+| dueDate     | YYYY-MM-DD                   |
+| description | Optional text                |
+
+---
+
+## Examples
+
+**Adding a Task:**
+
+```bash
+tn a
+```
+
+```
+Task Title: Buy groceries
+Task Status: → todo
+Task Priority: → medium
+Due Date (YYYY-MM-DD): 2026-02-01
+Task Description (optional): Buy fruits and vegetables
+```
+
+**Listing Tasks:**
+
+```bash
+tn ls
+```
+
+```
+┌─┬────┬────────────────┬─────────────┬─────────┬────────────┬─────────────────────────────┐
+│#│ ID │ Title          │ Status      │ Priority│ DueDate    │ Description                 │
+├─┼────┼────────────────┼─────────────┼─────────┼────────────┼─────────────────────────────┤
+│1│ 1  │ Buy groceries  │ todo        │ medium  │ 2026-02-01 │ Buy fruits and vegetables  │
+└─┴────┴────────────────┴─────────────┴─────────┴────────────┴─────────────────────────────┘
+```
+
+**Updating a Task:**
+
+```bash
+tn up
+```
+
+**Deleting a Task:**
+
+```bash
+tn del
+```
+
+**Undo Last Deleted Task:**
+
+```bash
+tn un
+```
+
+**Search Tasks:**
+
+```bash
+tn sr groceries
+```
+
+**Sort Tasks:**
+
+```bash
+tn so
+```
 
-## Contribution Guidelines
+* Select `dueDate`, `priority`, or `status` interactively
+* Or use `--by` option: `tn so --by priority`
 
-We welcome contributions to improve TaskNinja! Whether it's bug fixes, new features, or documentation enhancements, follow these steps:
+---
 
-### How to Contribute
+## Notes
 
-1. **Fork the Repository**:
-   - Go to the [GitHub repo](https://github.com/yourusername/taskninja) and click "Fork".
+* All selection prompts use **arrow keys** in terminal.
+* Task table always shows **numbered index (`#`) starting from 1**.
+* Status and priority are displayed in **colors** for better readability.
 
-2. **Clone Your Fork**:
-   ```bash
-   git clone https://github.com/yourusername/taskninja.git
-   cd taskninja
-   ```
+---
 
-3. **Create a Branch**:
-   - Use a descriptive name: `git checkout -b feature/new-feature` or `git checkout -b fix/bug-fix`.
+---
 
-4. **Make Changes**:
-   - Follow the existing code style (ESLint can be added later for consistency).
-   - Add or update tests if applicable.
-   - Ensure your code handles errors gracefully and maintains validation logic.
+## Screenshots / Demo
 
-5. **Commit Changes**:
-   - Use clear commit messages: e.g., "feat: add search functionality" or "fix: resolve date validation issue".
-   - Reference issues if relevant: e.g., "Closes #123".
+**Adding a Task:**
 
-6. **Push to Your Fork**:
-   ```bash
-   git push origin feature/new-feature
-   ```
+![Add Task](images/add.png "Adding a Task in TaskNinja CLI")
 
-7. **Open a Pull Request (PR)**:
-   - Go to the original repo and click "New Pull Request".
-   - Provide a detailed description of your changes, including why they're needed and any relevant screenshots.
-   - Link to any related issues.
+**Listing Tasks:**
 
-### Guidelines
+![List Tasks](images/list.png "Listing Tasks in TaskNinja CLI")
 
-- **Code Style**: Use consistent indentation (2 spaces), semicolons, and follow ES6+ best practices.
-- **Testing**: Add unit tests using a framework like Jest if expanding features. Currently, no tests are implemented—contributions here are encouraged!
-- **Dependencies**: Keep them minimal. Justify any new additions.
-- **Features**: New commands or options should align with the simple CLI philosophy. Discuss major changes in an issue first.
-- **Documentation**: Update README.md with any new features or changes.
-- **Issues**: Check for existing issues before creating a new one. Use labels like "bug", "enhancement", or "question".
+**Updating a Task:**
 
-### Code of Conduct
+![Update Task](images/update.png "Updating a Task")
 
-- Be respectful and inclusive.
-- No harassment or discrimination.
-- Report issues to the maintainer (Mohamed Bakr).
+**Deleting a Task:**
 
-By contributing, you agree that your contributions will be licensed under the ISC License.
+![Delete Task](images/delete.png "Deleting a Task")
+![Delete Task](images/delete2.png "Deleting a Task")
 
-## License
+**Restore Last-Deleted Task:**
 
-This project is licensed under the ISC License.
+![Undo](images/undo.png "Restore Last-deleted task")
 
-## Author
+**Search / Sort Tasks:**
 
-- **Mohamed Bakr** - Just a Developer - [GitHub Profile](https://github.com/MoBMoCaffeine)
+![Search Tasks](images/search.png "Searching Tasks")
+![Sort Tasks](images/sort.png "Sorting Tasks")
+![Sort Tasks-2](images/sort2.png "Sorting Tasks")
 
-## Acknowledgments
+**Mark as Done:**
 
-- Inspired by simple CLI tools like Todoist CLI.
-- Thanks to the open-source community for libraries like Commander and Inquirer.
+![Mark Task As Done](images/done.png "Mark as Done In one step")
+![Mark Task As Done](images/done2.png "Mark as Done In one step")
 
-If you encounter issues or have suggestions, open an issue on GitHub!
+---

package/app.js

@@ -1,6 +1,6 @@
 #! /usr/bin/env node
-
 /**
+ * TASKNINJA -
  * Task Manager CLI Application
  * This application allows users to manage their tasks via command line interface.
  * It supports adding, listing, and removing tasks.
@@ -9,78 +9,78 @@
  * - inquirer: For interactive prompts
  * - fs: For file system operations
  * Author: Mohamed Bakr
- * Date: June 2024
- * Version: 1.0.0
+ * Date: January 2024
+ * Version: 1.1.0
  */
 
 // for using commands in terminal
 import { Command } from "commander";
 // for interactive command line prompts
 import inquirer from "inquirer";
-// for file system operations
-import fs from "fs/promises";
+// supporting colors in table forms
+import Table from 'cli-table3';
+// for colored text 
+import chalk from 'chalk';
 
 // assigning Commander to a variable
 const program = new Command();
 
-// file to store tasks
-const TASKS_FILE = "./todos.json";
-// allowed task statuses
-const ALLOWED_STATUSES = ["todo", "in-progress", "done"];
-// allowed task priorities
-const ALLOWED_PRIORITIES = ["low", "medium", "high"];
-
-
-// function to load tasks from file
-const loadTasks = async () => {
-    try{
-        const data = await fs.readFile(TASKS_FILE, 'utf8');
-        return JSON.parse(data);
-    } catch (error) {
-        if (error.code === 'ENOENT') return [];
-        throw error;
-    }
-};
-// function to save tasks to file
-const saveTasks = async (tasks) => {
-    await fs.writeFile(TASKS_FILE, JSON.stringify(tasks, null, 2));
-};
-// get next task ID
-const getNextId = (tasks) => {
-    return tasks.length > 0 ? Math.max(...tasks.map(task => task.id)) + 1 : 1;
-};
-// validate task status
-const validateStatus = (status) => {
-    if (!ALLOWED_STATUSES.includes(status)) {
-        throw new Error(`Invalid status. Allowed statuses are: ${ALLOWED_STATUSES.join(", ")}`);
-    }
-};
-// validate task priority
-const validatePriority = (priority) => {
-    if (!ALLOWED_PRIORITIES.includes(priority)) {
-        throw new Error(`Invalid priority. Allowed priorities are: ${ALLOWED_PRIORITIES.join(", ")}`);
-    }  
-};
-// verify due date format
-const validateDueDate = (dueDate) => {
-    if (isNaN(Date.parse(dueDate))) {
-        throw new Error("Invalid due date. Please use a valid date format (YYYY-MM-DD).");
+// importing validators and allowed values
+import { validateDueDate, ALLOWED_PRIORITIES, ALLOWED_STATUSES } from "./utils/validators.js";
+// importing task service functions
+import { loadTasks, saveTasks, getNextId, saveDeletedTask, loadDeletedTask, clearDeletedTask  } from "./utils/taskService.js";
+
+
+// helper function to display tasks in colored table
+const displayTasks = (tasks) => {
+    if (!tasks.length) {
+        console.log(chalk.yellow("No tasks to display."));
+        return;
     }
-};
 
+    const table = new Table({
+        head:  [
+        chalk.cyanBright('#'),
+        chalk.cyanBright('ID'),
+        chalk.cyanBright('Title'),
+        chalk.cyanBright('Status'),
+        chalk.cyanBright('Priority'),
+        chalk.cyanBright('DueDate'),
+        chalk.cyanBright('Description')
+    ],
+        colWidths: [4, 4, 30, 12, 10, 12, 60]
+    });
+
+    tasks.forEach((task, index) => {
+        table.push([
+            index + 1,
+            task.id,
+            task.title,
+            task.status === "done" ? chalk.green(task.status)
+            : task.status === "in-progress" ? chalk.yellow(task.status)
+            : chalk.blue(task.status),
+            task.priority === "high" ? chalk.red(task.priority)
+            : task.priority === "medium" ? chalk.yellow(task.priority)
+            : chalk.green(task.priority),
+            task.dueDate,
+            task.description || ''
+        ]);
+    });
 
+    console.log(table.toString());
+};
 // setting up
 program
-    .name("todo-cli")
+    .name("taskninja")
     .description("A simple CLI application to manage your tasks")
-    .version("1.0.0");
+    .version("1.1.0");
 
 // use command 'add' with title + status + priority + dueDate + description and action
 program
     .command('add')
     .alias('a')
     .description('Add a new task')
-    .action(async (title, status, priority, dueDate, description = "") => {
+    .action(async () => {
         const answers = await inquirer.prompt([
             {
                 type: 'input',
@@ -89,14 +89,14 @@ program
                 validate : input => input ? true : 'Title cannot be empty!'
             },
             {
-                type: 'list',
+                type: 'rawlist',
                 name: 'status',
                 message : 'Task Status:',
                 choices : ALLOWED_STATUSES,
                 default : 'todo'
             },
             {
-                type: 'list',
+                type: 'rawlist',
                 name: 'priority',
                 message : 'Task Priority:',
                 choices : ALLOWED_PRIORITIES,
@@ -119,7 +119,7 @@ program
                 type: 'input',
                 name: 'description',
                 message : 'Task Description (optional):'    
-            }
+            },
         ]);
     // load existing tasks
     const tasks = await loadTasks();
@@ -137,7 +137,7 @@ program
     tasks.push(newTask);
     // save updated tasks to file
     await saveTasks(tasks);
-    console.log("Task added successfully!");
+    console.log(chalk.green('Task added successfully!'));
 });
 
 
@@ -146,102 +146,332 @@ program
     .command('list')
     .alias('ls')
     .description('List all tasks')
-    .option('-s, --status <status>', 'Filter tasks by status')
+    .option('-s, --status <status>', 'Filter tasks by status (todo, in-progress, done)')
     .action(async (options) => {
         let tasks = await loadTasks();
 
         if (options.status) {
             if (!ALLOWED_STATUSES.includes(options.status)){
-                console.error(`Invalid status filter. Allowed statuses are: ${ALLOWED_STATUSES.join(", ")}`);
-                process.exit(1);
+                console.log(chalk.red(`Invalid status filter. Allowed statuses are: ${ALLOWED_STATUSES.join(", ")}`));
+                return;
             }
             tasks = tasks.filter(task => task.status === options.status);
         }
-        if (tasks.length === 0) {
-            console.log('No tasks found.');
+        // display all tasks in table format
+        displayTasks(tasks);
+    });
+
+
+
+// use command 'search' to find tasks by keyword in title or description
+program
+    .command('search [keyword]')
+    .alias('sr')
+    .option('-f, --find <keyword>', 'Keyword to search in title or description')
+    .description('Search tasks by keyword in title or description')
+    .action(async (keyword, options) => {
+        const tasks = await loadTasks();
+        let searchTerm = keyword || options.find;
+
+        if (!searchTerm) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'term',
+                    message: 'Enter the keyword you want to search for:',
+                    validate: input => input ? true : 'Keyword cannot be empty!'
+                },
+                {
+                    type: 'rawlist',
+                    name: 'field',
+                    message: 'Where do you want to search?',
+                    choices: ['title', 'description', 'both'],
+                    default: 'both'
+                }
+            ]);
+            searchTerm = answers.term;
+            const field = answers.field;
+
+            const founded = tasks.filter(task => {
+                if (field === 'title') return task.title.toLowerCase().includes(searchTerm.toLowerCase());
+                if (field === 'description') return task.description.toLowerCase().includes(searchTerm.toLowerCase());
+                return task.title.toLowerCase().includes(searchTerm.toLowerCase()) || 
+                       task.description.toLowerCase().includes(searchTerm.toLowerCase());
+            });
+
+            if (founded.length === 0) {
+                console.log(chalk.red('No task matched your search!'));
+                return;
+            }
+
+            displayTasks(founded);
             return;
         }
-       // map all tasks to displayable objects
-        const tableData = tasks.map(task => ({
-            ID: task.id,
-            Title: task.title,
-            Status: task.status,
-            Priority: task.priority,
-            DueDate: task.dueDate,
-            Description: task.description || ''
-        }));
 
-        // display all tasks in table format
-        console.table(tableData);
+        const founded = tasks.filter(task =>
+            task.title.toLowerCase().includes(searchTerm.toLowerCase()) ||
+            task.description.toLowerCase().includes(searchTerm.toLowerCase())
+        );
+
+        if (founded.length === 0) {
+            console.log(chalk.red('No task matched your search!'));
+            return;
+        }
+
+        displayTasks(founded);
+    });
+
+
+
+
+// use command 'sort' to sort tasks by due date, priority, or status
+program
+    .command('sort')
+    .alias('so')
+    .option('--by <criteria>', 'Sort tasks by criteria (dueDate, priority, status)')
+    .description('Sort tasks by due date, priority, or status')
+    .action( async (options) => {
+
+        const tasks = await loadTasks();
+        let criteria = options.by;
+
+        if (!criteria) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'rawlist',
+                    name: 'criteria',
+                    message: 'Sort tasks by:',
+                    choices: ['dueDate', 'priority', 'status']
+                }
+            ]);
+            criteria = answer.criteria;
+        }
+
+        
+        if (!['dueDate', 'priority', 'status'].includes(criteria)) {
+            console.log(chalk.red('Invalid sort criteria. Use --by with dueDate, priority, or status.'));
+            return;
+        }
+        // sorting logic
+        const sortedTasks = [...tasks];
+
+        switch (criteria) {
+            case 'dueDate' || 'duedate' || 'DueDate' || 'Duedate' || 'due date' || 'Due date' || 'due-date':
+                sortedTasks.sort((a, b) => new Date(a.dueDate) - new Date(b.dueDate));
+                break;
+            case 'priority' || 'Priority':
+                const priorityOrder = { 'high': 1, 'medium': 2, 'low': 3 };
+                sortedTasks.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+                break;
+            case 'status' || 'Status':
+                const statusOrder = { 'todo': 1, 'in-progress': 2, 'done': 3 };
+                sortedTasks.sort((a, b) => statusOrder[a.priority] - statusOrder[b.priority]);
+                break;
+            default:
+                console.log(chalk.red('Invalid sort criteria. Use dueDate, priority, or status.'));
+                return;
+        }
+
+        displayTasks(sortedTasks);
     });
 
+
 // use command 'update' with task ID and action
 program 
     .command('update')
     .alias('up')
-    .description('Update a task by ID')
+    .description('Update a task by ==> ID <==')
     .action(async () =>{
         const tasks = await loadTasks();
         if (tasks.length === 0) {
-            console.log('No tasks found to update.');
+            console.log(chalk.red('No tasks found to update.'));
             return;
         }
 
         const { id } = await inquirer.prompt([
             {
-                type: 'list',
+                type: 'rawlist',
                 name: 'id',
-                message: 'Select the task to update:',
+                message: 'Select the task to update (By ID):',
                 choices: tasks.map(task => ({ name: `${task.id}: ${task.title}`, value: task.id }))
             }
         ]);
-        const { status } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'status',
-                message: 'Select the new status:',
-                choices: ALLOWED_STATUSES
-            }
-        ]);
 
+        // find the task to update
         const task = tasks.find(t => t.id === Number(id));
         if (!task) {
-            console.error('Task not found!');
+            console.log(chalk.red('Task not found!'));
             return;
         }
-        task.status = status;
 
-        await saveTasks(tasks);
-        console.log('Task updated successfully!');
+        const answers = await inquirer.prompt([
+      // for title
+        {
+            type: 'confirm',
+            name: 'changeTitle',
+            message: 'Do you want to change the title?',
+            default: false
+        },
+        {
+            type: 'input',
+            name: 'title',
+            message: 'Enter the new title:',
+            when: answers => answers.changeTitle,
+            validate: input => input ? true : 'Title cannot be empty!'
+        },
 
-        const tableData = tasks.map(task => ({
-            ID: task.id,
-            Title: task.title,
-            Status: task.status,
-            Priority: task.priority,
-            DueDate: task.dueDate,
-            Description: task.description || ''
-        }));
+      // for status
+        {
+            type: 'confirm',
+            name: 'changeStatus',
+            message: 'Do you want to change the status?',
+            default: false
+        },
+        {
+            type: 'rawlist',
+            name: 'status',
+            message: 'Select the new status:',
+            choices: ALLOWED_STATUSES,
+            when: answers => answers.changeStatus
+        },
 
-        // display all tasks in table format
-        console.table(tableData);
+      // for priority
+        {
+            type: 'confirm',
+            name: 'changePriority',
+            message: 'Do you want to change the priority?',
+            default: false
+        },
+        {
+            type: 'rawlist',
+            name: 'priority',
+            message: 'Select the new priority:',
+            choices: ALLOWED_PRIORITIES,
+            when: answers => answers.changePriority
+        },
+
+      // for due date
+        {
+            type: 'confirm',
+            name: 'changeDueDate',
+            message: 'Do you want to change the due date?',
+            default: false
+        },
+        {
+            type: 'input',
+            name: 'dueDate',
+            message: 'Enter the new due date (YYYY-MM-DD):',
+            when: answers => answers.changeDueDate,
+            validate: input => {
+                try {
+                    validateDueDate(input);
+                    return true;
+                } catch (error) {
+                    return error.message;
+                }
+            }
+        },
+
+      // for description
+        {
+            type: 'confirm',
+            name: 'changeDescription',
+            message: 'Do you want to change the description?',
+            default: false
+        },
+        {
+            type: "rawlist",
+            name: 'description',
+            message: 'Enter the new description:',
+            when: answers => answers.changeDescription
+        }
+    ]);
+
+    // apply updates only if user chose to change them
+    if (answers.changeTitle) task.title = answers.title;
+    if (answers.changeStatus) task.status = answers.status;
+    if (answers.changePriority) task.priority = answers.priority;
+    if (answers.changeDueDate) task.dueDate = answers.dueDate;
+    if (answers.changeDescription)
+        task.description = answers.description || '';
+
+    // is there any change?
+    const hasChanges = [
+            answers.changeTitle,
+            answers.changeStatus,
+            answers.changePriority,
+            answers.changeDueDate,
+            answers.changeDescription
+        ].some(Boolean);
+
+        if (!hasChanges) {
+            console.log(chalk.yellow('No changes were made.'));
+        }else {
+            // save updated tasks to file
+            await saveTasks(tasks);
+            console.log(chalk.green('Task updated successfully!'));
+        }
+    
+        displayTasks(tasks);
+    });
+
+
+// use command 'done' with task ID instead of 'update' + confirm to mark task as done
+program
+    .command('done')
+    .description('Mark a task as done by ==> ID <==')
+    .action(async () => {
+        const tasks = await loadTasks();
+        if (tasks.length === 0) {
+            console.log(chalk.magenta('Congratulations! All tasks are already done.'));
+            return;
+        }
+
+        const activeTasks = tasks.filter(t => t.status !== 'done');
+        if (activeTasks.length === 0) {
+            console.log(chalk.magenta('Congratulations! All tasks are already done.'));
+            return;
+        }
+
+        const { id } = await inquirer.prompt([
+            {
+                type: 'rawlist',
+                name: 'id',
+                message: 'Select the task to mark as done:',
+                choices: activeTasks.map(t => (
+                    {
+                        name: `${t.id}: ${t.title}[Current Status: ${t.status}]`,
+                        value: t.id
+                    }
+                ))
+            }
+        ]);
+
+        const task = tasks.find(t => t.id === Number(id));
+        task.status = 'done';
+        await saveTasks(tasks);
+        console.log(chalk.green('Task marked as done successfully!'));
+
+        displayTasks(tasks);
     });
 
+
+
 // use command 'delete' with task ID and action
 program
     .command('delete')
     .alias('del')
-    .description('delete a task by ID')
+    .description('delete a task by ==> ID <==')
     .action(async () => {
         const tasks = await loadTasks();
         if (tasks.length === 0) {
-            console.log('No tasks found to delete.');
+            console.log(chalk.yellow('No tasks found to delete.'));
             return;
         }
 
         const { id } = await inquirer.prompt([
             {
-                type: 'list',
+                type: 'rawlist',
                 name: 'id',
                 message: 'Select the task to delete:',
                 choices: tasks.map(task => ({ name: `${task.id}: ${task.title}`, value: task.id }))
@@ -257,26 +487,44 @@ program
             }
         ]);
         if (!confirm) {
-            console.log('Task deletion cancelled.');
+            console.log(chalk.yellow('Task deletion cancelled.'));
             return;
         }
+        const taskToDelete = tasks.find(t => t.id === Number(id));
+        // save deleted task for undo functionality
+        await saveDeletedTask(taskToDelete);
+        // filter out the deleted task
+        const newTasks = tasks.filter(t => t.id !== Number(id));
 
-        const newTasks = tasks.filter(t => t.id !== id);
         await saveTasks(newTasks);
-        console.log('Task deleted successfully!');
-
-        const tableData = tasks.map(task => ({
-            ID: task.id,
-            Title: task.title,
-            Status: task.status,
-            Priority: task.priority,
-            DueDate: task.dueDate,
-            Description: task.description || ''
-        }));
+        console.log(chalk.green('Task deleted successfully!'));
+        console.log(chalk.cyan('You can undo this action by using the `undo` command.'));
 
-        // display all tasks in table format
-        console.table(tableData);
+        displayTasks(newTasks);
     });
 
+// use command 'undo' to restore last deleted task
+program
+.command('undo')
+.alias('un')
+.description('Undo the last deleted task')
+.action( async () => {
+    const lastDeletedTask =  await loadDeletedTask();
+    if (!lastDeletedTask) {
+        console.log(chalk.yellow('No deleted task to restore.'));
+        return;
+    }
+
+    const tasks = await loadTasks();
+    tasks.push(lastDeletedTask);
+    tasks.sort((a, b) => a.id - b.id); // keep tasks sorted by ID
+    await saveTasks(tasks);
+    await clearDeletedTask();
+
+    console.log(chalk.green(`Last deleted task restored successfully!, (Task name: ${lastDeletedTask.title})`));
+});
+
+
+
 // parse command line arguments
 program.parse(process.argv);

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "taskninja",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "a simple CLI application with JS as a (To-Do Application)",
   "main": "app.js",
-  "type" : "module",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "start": "node app.js",
     "dev": "node app.js"
   },
-  "bin" : {
+  "bin": {
     "dotask": "./app.js",
     "taskninja": "./app.js",
     "tn": "./app.js"
@@ -17,6 +17,8 @@
   "author": "Moahmed Bakr",
   "license": "ISC",
   "dependencies": {
+    "chalk": "^5.6.2",
+    "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
     "inquirer": "^13.2.1"
   }

package/utils/taskService.js

@@ -0,0 +1,63 @@
+// for file system operations
+import fs from "fs/promises";
+
+
+// file to store tasks
+const TASKS_FILE = "./todos.json";
+
+// file to temporarily store deleted tasks for undo functionality
+export const DELETED_TASKS_FILE = "./deleted_todos.json";
+
+
+/**
+ * @description this section responsible to store tasks in todo.json
+ */
+// function to load tasks from file
+export const loadTasks = async () => {
+    try{
+        const data = await fs.readFile(TASKS_FILE, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        if (error.code === 'ENOENT') return [];
+        throw error;
+    }
+};
+// function to save tasks to file
+export const saveTasks = async (tasks) => {
+    await fs.writeFile(TASKS_FILE, JSON.stringify(tasks, null, 2));
+};
+// get next task ID
+export const getNextId = (tasks) => {
+    return tasks.length > 0 ? Math.max(...tasks.map(task => task.id)) + 1 : 1;
+};
+
+/**
+ * @description this section responsible to store deleted tasks in deleted_todos.json
+ * for undo functionality
+ */
+// to save deleted last-deleted task
+export const saveDeletedTask = async (task) => {
+    await fs.writeFile(DELETED_TASKS_FILE, JSON.stringify(task, null, 2));
+}
+
+// to load deleted last-deleted task
+export const loadDeletedTask = async () => {
+    try {
+        const data = await fs.readFile(DELETED_TASKS_FILE, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        if (error.code === 'ENOENT') return null;
+        throw error;
+    }
+};
+
+// to clear deleted tasks file after undo
+export const clearDeletedTask = async () => {
+    try {
+        await fs.unlink(DELETED_TASKS_FILE);
+    } catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+};

package/utils/validators.js

@@ -0,0 +1,26 @@
+
+// allowed task statuses
+const ALLOWED_STATUSES = ["todo", "in-progress", "done"];
+// allowed task priorities
+const ALLOWED_PRIORITIES = ["low", "medium", "high"];
+
+// validate task status
+export const validateStatus = (status) => {
+    if (!ALLOWED_STATUSES.includes(status)) {
+        throw new Error(`Invalid status. Allowed statuses are: ${ALLOWED_STATUSES.join(", ")}`);
+    }
+};
+// validate task priority
+export const validatePriority = (priority) => {
+    if (!ALLOWED_PRIORITIES.includes(priority)) {
+        throw new Error(`Invalid priority. Allowed priorities are: ${ALLOWED_PRIORITIES.join(", ")}`);
+    }  
+};
+// verify due date format
+export const validateDueDate = (dueDate) => {
+    if (isNaN(Date.parse(dueDate))) {
+        throw new Error("Invalid due date. Please use a valid date format (YYYY-MM-DD).");
+    }
+};
+
+export { ALLOWED_PRIORITIES, ALLOWED_STATUSES };