taskninja 1.1.6 → 1.1.8

package/src/commands/deleteCommand.js

@@ -0,0 +1,51 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { loadTasks, saveTasks, saveDeletedTask } from '../utils/taskService.js';
+import { displayTasks, cleanupAndExit } from '../helpers/helpers.js';
+
+export const deleteAction = async () => {
+    try {
+        const tasks = await loadTasks();
+        if (!tasks.length) {
+            console.log(chalk.yellow('No tasks found to delete.'));
+            cleanupAndExit(0);
+        }
+
+        const { id } = await inquirer.prompt([
+            {
+                type: 'rawlist',
+                name: 'id',
+                message: 'Select the task to delete:',
+                choices: tasks.map(task => ({ name: `${task.id}: ${task.title}`, value: task.id }))
+            }
+        ]);
+        
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you sure you want to delete this task?',
+                default: false
+            }
+        ]);
+        
+        if (!confirm) {
+            console.log(chalk.yellow('Task deletion cancelled.'));
+            cleanupAndExit(0);
+        }
+        
+        const taskToDelete = tasks.find(t => t.id === Number(id));
+        await saveDeletedTask(taskToDelete); 
+        
+        const newTasks = tasks.filter(t => t.id !== Number(id));
+        await saveTasks(newTasks); 
+
+        console.log(chalk.green('Task deleted successfully!'));
+        console.log(chalk.cyan('You can undo this action by using the `undo` command.'));
+        displayTasks(newTasks);
+    } catch (error) {
+        console.log(chalk.yellow('\nOperation Cancelled!'));
+    } finally {
+        cleanupAndExit(0);
+    }
+};

package/src/commands/doneCommand.js

@@ -0,0 +1,36 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadTasks, saveTasks } from "../utils/taskService.js";
+import { displayTasks, cleanupAndExit } from "../helpers/helpers.js";
+
+export const doneAction = async () => {
+    try {
+        const tasks = await loadTasks();
+        const activeTasks = tasks.filter(t => t.status !== 'done');
+        
+        if (!activeTasks.length) {
+            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);
+    } catch (error) {
+        console.log(chalk.yellow('\nOperation Cancelled!'));
+    } finally {
+        cleanupAndExit(0);
+    }
+};

package/src/commands/listCommand.js

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import { loadTasks } from "../utils/taskService.js";
+import { displayTasks, cleanupAndExit } from "../helpers/helpers.js";
+import { ALLOWED_STATUSES } from "../utils/validators.js";
+
+export const listAction = async (options) => {
+    let tasks = await loadTasks();
+
+    if (options.status) {
+        if (!ALLOWED_STATUSES.includes(options.status)) {
+            console.log(chalk.red(`Invalid status filter. Allowed statuses are: ${ALLOWED_STATUSES.join(", ")}`));
+            cleanupAndExit(0);
+        }
+        tasks = tasks.filter(task => task.status === options.status);
+    }
+    
+    displayTasks(tasks);
+    cleanupAndExit(0);
+};

package/src/commands/searchCommand.js

@@ -0,0 +1,48 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadTasks } from "../utils/taskService.js";
+import { displayTasks, cleanupAndExit } from "../helpers/helpers.js";
+
+export const searchAction = async (keyword, options) => {
+    try {
+        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) {
+                console.log(chalk.red('No task matched your search!'));
+                return;
+            }
+            displayTasks(founded);
+            return;
+        }
+
+        const founded = tasks.filter(task =>
+            task.title.toLowerCase().includes(searchTerm.toLowerCase()) ||
+            task.description.toLowerCase().includes(searchTerm.toLowerCase())
+        );
+
+        if (!founded.length) {
+            console.log(chalk.red('No task matched your search!'));
+            return;
+        }
+        displayTasks(founded);
+    } catch (error) {
+        console.log(chalk.yellow('\nOperation Cancelled!'));
+    } finally {
+        cleanupAndExit(0);
+    }
+};

package/src/commands/sortCommand.js

@@ -0,0 +1,47 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadTasks } from "../utils/taskService.js";
+import { displayTasks, cleanupAndExit } from "../helpers/helpers.js";
+
+export const sortAction = async (options) => {
+    try {
+        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;
+        }
+        
+        criteria = criteria.toLowerCase().replace(/[-_]/g, '');
+        
+        if (!['duedate', 'priority', 'status'].includes(criteria)) {
+            console.log(chalk.red('Invalid sort criteria. Use --by with dueDate, priority, or status.'));
+            return;
+        }
+        
+        const sortedTasks = [...tasks];
+
+        switch (criteria) {
+            case 'duedate':
+                sortedTasks.sort((a, b) => new Date(a.dueDate) - new Date(b.dueDate));
+                break;
+            case 'priority':
+                const priorityOrder = { 'high': 1, 'medium': 2, 'low': 3 };
+                sortedTasks.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+                break;
+            case 'status':
+                const statusOrder = { 'todo': 1, 'in-progress': 2, 'done': 3 };
+                sortedTasks.sort((a, b) => statusOrder[a.status] - statusOrder[b.status]);
+                break;
+        }
+
+        displayTasks(sortedTasks);
+    } catch (error) {
+        console.log(chalk.yellow('\nOperation Cancelled!'));
+    } finally {
+        cleanupAndExit(0);
+    }
+};

package/src/commands/undoCommand.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+import { loadTasks, saveTasks, loadDeletedTasks, saveDeletedTasksFile, cleanupExpiredDeletedTasks } from '../utils/taskService.js';
+import { cleanupAndExit } from '../helpers/helpers.js';
+
+export const undoAction = async () => {
+    try {
+        await cleanupExpiredDeletedTasks();
+
+        const deletedTasks = await loadDeletedTasks();
+        if (!deletedTasks || deletedTasks.length === 0) {
+            console.log(chalk.yellow('No deleted task to restore.'));
+            return;
+        }
+
+        const lastDeletedTask = deletedTasks.pop();
+
+        const { deletedAt, expiredAfter, ...cleanTask } = lastDeletedTask;
+
+        const tasks = await loadTasks();
+        tasks.push(cleanTask); 
+        tasks.sort((a, b) => a.id - b.id); 
+        await saveTasks(tasks);
+
+        await saveDeletedTasksFile(deletedTasks);
+
+        console.log(chalk.green(`Last deleted task restored successfully! (Task name: ${cleanTask.title})`));
+    } catch (error) {
+        console.log(chalk.red('An error occurred during undo operation.'));
+    } finally {
+        cleanupAndExit(0);
+    }
+};

package/src/commands/updateCommand.js

@@ -0,0 +1,62 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadTasks, saveTasks } from "../utils/taskService.js";
+import { displayTasks, cleanupAndExit } from "../helpers/helpers.js";
+import { validateDueDate, ALLOWED_PRIORITIES, ALLOWED_STATUSES } from "../utils/validators.js";
+
+export const updateAction = async () => {
+    try {
+        const tasks = await loadTasks();
+        if (!tasks.length) {
+            console.log(chalk.red('No tasks found to update.'));
+            cleanupAndExit(0);
+        }
+        
+        const { id } = await inquirer.prompt([
+            {
+                type: 'rawlist',
+                name: 'id',
+                message: 'Select the task to update (By ID):',
+                choices: tasks.map(task => ({ name: `${task.id}: ${task.title}`, value: task.id }))
+            }
+        ]);
+
+        const task = tasks.find(t => t.id === Number(id));
+        
+        const answers = await inquirer.prompt([
+            { type: 'confirm', name: 'changeTitle', message: 'Do you want to change the title?', default: false },
+            { type: 'input', name: 'title', message: 'Enter the new title:', when: a => a.changeTitle, validate: input => input ? true : 'Title cannot be empty!' },
+            { 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: a => a.changeStatus },
+            { 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: a => a.changePriority },
+            { 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: a => a.changeDueDate,
+                validate: input => { try { validateDueDate(input); return true; } catch (error) { return error.message; } }
+            },
+            { type: 'confirm', name: 'changeDescription', message: 'Do you want to change the description?', default: false },
+            { type: 'input', name: 'description', message: 'Enter the new description:', when: a => a.changeDescription }
+        ]);
+
+        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 || '';
+
+        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 {
+            await saveTasks(tasks);
+            console.log(chalk.green('Task updated successfully!'));
+        }
+        displayTasks(tasks);
+    } catch (error) {
+        console.log(chalk.yellow('\nOperation Cancelled!'));
+    } finally {
+        cleanupAndExit(0);
+    }
+};

package/src/helpers/helpers.js

@@ -3,8 +3,6 @@
 import Table from 'cli-table3';
 // for colored text 
 import chalk from 'chalk';
-// for reading keyboard buttons
-import readline from 'readline';
 
 // helper function to display tasks in colored table
 const displayTasks = (tasks) => {
@@ -52,19 +50,4 @@ const cleanupAndExit = (code = 0) => {
     process.exit(code);
 };
 
-const enableEscExit = () => {
-    readline.emitKeypressEvents(process.stdin);
-
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-    }
-
-    process.stdin.on('keypress', (_, key) => {
-        if (key?.name === 'escape'){
-            console.log(chalk.yellow('\nOperation Cancelled!'));
-            cleanupAndExit(0);
-        }
-    });
-};
-
-export {displayTasks, enableEscExit, cleanupAndExit};
+export {displayTasks, cleanupAndExit};

package/src/utils/taskService.js

@@ -24,7 +24,17 @@ export const loadTasks = async () => {
 };
 // function to save tasks to file
 export const saveTasks = async (tasks) => {
-    await fs.writeFile(TASKS_FILE, JSON.stringify(tasks, null, 2));
+    
+    if (tasks.length === 0) {
+        try {
+            await fs.unlink(TASKS_FILE);
+        } catch (error) {
+            if (error.code !== 'ENOENT') throw error;
+        }
+    }
+    else {
+        await fs.writeFile(TASKS_FILE, JSON.stringify(tasks, null, 2));
+    }
 };
 // get next task ID
 export const getNextId = (tasks) => {
@@ -37,18 +47,31 @@ export const getNextId = (tasks) => {
  */
 
 // to load deleted last-deleted task
-export const loadDeletedTask = async () => {
+export const loadDeletedTasks = async () => {
     try {
         const data = await fs.readFile(DELETED_TASKS_FILE, 'utf8');
         return JSON.parse(data);
     } catch (error) {
-        if (error.code === 'ENOENT') return null;
+        if (error.code === 'ENOENT') return [];
         throw error;
     }
 };
 // to save deleted last-deleted task
+
+export const saveDeletedTasksFile = async(deletedTasks) => {
+    if (deletedTasks.length === 0) {
+        try {
+            await fs.unlink(DELETED_TASKS_FILE);
+        } catch (error) {
+            if (error.code !== 'ENOENT') throw error;
+        }
+    }
+    else {
+        await fs.writeFile(DELETED_TASKS_FILE, JSON.stringify(deletedTasks, null, 2));
+    }
+};
 export const saveDeletedTask = async (task, expiredAfter = 60000) => {
-    const deletedTask = await loadDeletedTask(task) || [];
+    const deletedTask = await loadDeletedTasks();
     const now = Date.now();
 
     deletedTask.push({
@@ -57,17 +80,19 @@ export const saveDeletedTask = async (task, expiredAfter = 60000) => {
         expiredAfter
     });
 
-    await fs.writeFile(DELETED_TASKS_FILE, JSON.stringify(deletedTask, null, 2));
+    await saveDeletedTasksFile(deletedTask);
 }
 
 // function to delete all deleted-tasks after a while
 export const cleanupExpiredDeletedTasks = async () => {
-    const deletedTasks = await loadDeletedTask() || [];
+    const deletedTasks = await loadDeletedTasks();
+    if (deletedTasks.length === 0) return;
+
     const now = Date.now();
 
     const remaining = deletedTasks.filter(task => now - task.deletedAt < task.expiredAfter);
     if (remaining.length !== deletedTasks.length){
-        await fs.writeFile(DELETED_TASKS_FILE, JSON.stringify(remaining, null, 2));
+        await saveDeletedTasksFile(remaining);
     }
 }