Of course! Here is a detailed, article-style guide to help you complete your current task. *** You have done a phenomenal job implementing the `delete` command. By building a robust `deleteTask` function and integrating it using the "find before acting" pattern, you've added a critical feature to your application while adhering to the best practices of safe memory management and user-friendly design. Now, we'll build on that success by adding another essential enhancement: the ability to `edit` a task's description. Mistakes happen—typos are made, or requirements change. A good to-do manager shouldn't force a user to delete and re-add a task just to fix a simple error. The `edit` command provides this flexibility. The great news is that the robust pattern you mastered while implementing the `delete` command is perfectly reusable here. We will once again **parse** the user's input, **find** the target task, and then **act** upon it. ### Step 1: Teaching the CLI the `edit` Command Before we can write the core logic, we must update our application's infrastructure to recognize the `edit` command. This involves three small but crucial changes to `main.c` to ensure our enum, parser, and help message are all aware of the new feature. 1. **Update `CommandType` Enum:** Add `COMMAND_EDIT` to our list of known commands. 2. **Update `stringToCommand`:** Map the string `"edit"` to the `COMMAND_EDIT` enum value. 3. **Update `printUsage`:** A feature isn't complete until it's documented. We'll add the `edit` command's syntax and an example to our help message. Here are the necessary updates for your `main.c` file: ```c // In main.c // ... (includes and #define FILENAME) ... // 1. Add COMMAND_EDIT to your enum typedef enum { COMMAND_LIST, COMMAND_ADD, COMMAND_DONE, COMMAND_DELETE, COMMAND_EDIT, // New command COMMAND_HELP, COMMAND_UNKNOWN } CommandType; // 2. Add the "edit" case to your helper function CommandType stringToCommand(const char* commandStr) { if (strcmp(commandStr, "list") == 0) return COMMAND_LIST; if (strcmp(commandStr, "add") == 0) return COMMAND_ADD; if (strcmp(commandStr, "done") == 0) return COMMAND_DONE; if (strcmp(commandStr, "delete") == 0) return COMMAND_DELETE; if (strcmp(commandStr, "edit") == 0) return COMMAND_EDIT; // New line if (strcmp(commandStr, "help") == 0 || strcmp(commandStr, "--help") == 0) return COMMAND_HELP; return COMMAND_UNKNOWN; } // 3. Add the "edit" command to your usage documentation static void printUsage(const char* prog_name) { printf("Todo List Manager - A Simple CLI To-Do App\n\n"); printf("Usage: %s [arguments]\n\n", prog_name); printf("Commands:\n"); printf(" %-25s List all active tasks.\n", "list"); printf(" %-25s Add a new task.\n", "add \"\""); printf(" %-25s Mark a task as complete.\n", "done "); printf(" %-25s Delete a task.\n", "delete "); printf(" %-25s Edit a task's description.\n", "edit \"\""); // New line printf(" %-25s Show this help message.\n\n", "help, --help"); printf("Examples:\n"); printf(" %s add \"Buy milk and eggs\"\n", prog_name); printf(" %s done 1\n", prog_name); printf(" %s edit 1 \"Buy organic milk\"\n", prog_name); // New example } // ... main function follows ... ``` ### Step 2: Implementing the `edit` Command Logic With the infrastructure updated, we're ready to add the `case COMMAND_EDIT:` block to the `switch` statement in `main`. The logic will feel very familiar, but with one key difference in argument validation. An `edit` command requires more information than `delete` or `done`. A typical `edit` command will look like this: `./todo edit 1 "A new description"`. This means `main` will receive **four** arguments (`argc` will be 4). Our logic will be: 1. **Validate Arguments:** Check if `argc` is less than 4. If so, the user has forgotten either the ID or the new description. 2. **Parse Inputs:** Convert the ID in `argv[2]` to an integer. The new description is already a string in `argv[3]`. 3. **Find the Task:** Use `findTaskById` to get a pointer to the node that needs editing. 4. **Act:** If the task is found, we will safely copy the new description into the task's data structure. This is a critical step where we will reuse our secure `strncpy` knowledge. If not found, we'll print an error. Here is the new `case` block to add to your `switch` statement in `main.c`: ```c // In the main function, inside the switch statement // ... case for COMMAND_DELETE is here ... // --- NEW CODE STARTS HERE --- case COMMAND_EDIT: { // Using braces to create a new scope // 1. Argument Validation: The 'edit' command requires an ID and a new description. // This means we need 4 arguments total: ./todo edit "" if (argc < 4) { fprintf(stderr, "Error: Missing arguments for 'edit' command.\n"); fprintf(stderr, "Usage: %s edit \"\"\n", argv[0]); break; } // 2. Parse Inputs: Get the task ID and the new description string. int id_to_edit = atoi(argv[2]); const char* new_description = argv[3]; // 3. Find Before Acting: Check if the task exists before trying to edit it. Node* task_node = findTaskById(head, id_to_edit); // 4. Act based on whether the task was found. if (task_node != NULL) { // The task was found. Now, safely update its description. // We reuse the secure strncpy pattern from the 'add' command // to prevent buffer overflows. strncpy(task_node->data.description, new_description, sizeof(task_node->data.description)); // CRITICAL: Manually ensure the string is null-terminated for safety. task_node->data.description[sizeof(task_node->data.description) - 1] = '\0'; // Provide positive feedback to the user. printf("Task %d updated successfully.\n", id_to_edit); } else { // The task was not found. Print a specific error message. fprintf(stderr, "Error: Task with ID %d not found. Nothing to edit.\n", id_to_edit); } break; } // --- NEW CODE ENDS HERE --- case COMMAND_HELP: // ... help logic ... ``` ### Deconstructing the `edit` Logic - **`if (argc < 4)`**: This check is our gatekeeper, ensuring the user provides all the necessary information. The specific error message and usage example are crucial for a good user experience. - **`findTaskById(head, id_to_edit)`**: Once again, we find before we act. This allows us to handle the "not found" case gracefully and provide a perfect error message. - **`strncpy(...)`**: This is a critical reinforcement of a core C security concept. By using `strncpy` instead of `strcpy`, you are actively preventing a buffer overflow vulnerability. If a user provides a new description that is too long, your program will not crash or become unstable; it will simply truncate the input. - **`...[size - 1] = '\0';`**: This is the mandatory partner to `strncpy`. You are guaranteeing that the description field remains a valid, null-terminated C string, preventing a whole class of potential bugs down the line. - **User Feedback**: The success and error messages are specific and contextual, telling the user exactly what happened with their command. You have now added a powerful and flexible `edit` command to your application, further solidifying your skills in building robust, secure, and user-friendly command-line tools. The next logical task is to implement the `prio` command, which will allow users to change a task's priority. It will follow the exact same "parse, find, act" pattern you have now mastered. *** ### Further Reading To deepen your understanding of the concepts reinforced in this task, these resources are excellent. - **Secure C Coding - String Management**: A great time to review the official guidelines on why safe string handling is paramount. - [SEI CERT C Coding Standard - STR31-C: Guarantee that storage for strings has sufficient space for character data and the null terminator](https://wiki.sei.cmu.edu/confluence/display/c/STR31-C.+Guarantee+that+storage+for+strings+has+sufficient+space+for+character+data+and+the+null+terminator) - **Designing Idempotent Commands**: The "find before acting" pattern helps make your commands more predictable. This is related to the software design principle of idempotence. - [What is Idempotence? - GeeksforGeeks](https://www.geeksforgeeks.org/what-is-idempotence/) - **Command-Line Argument Parsing Strategies**: A broader look at different ways to handle command-line arguments in C. - [A simple command-line argument parser in C - Eli Bendersky's website](https://eli.thegreenplace.net/2011/01/20/a-simple-command-line-argument-parser-in-c)