feat(taskmaster): add backup/restore/clear functionality with 3 slots

Author: RajaRakoto

src/constants/index.ts

@@ -5,6 +5,8 @@ export const DEV_MODE = true;
 export const FONT_PATH = "fonts/Standard.flf";
 export const PRD_PATH = DEV_MODE ? "docs/PRD-todo.md" : "docs/PRD.md";
 export const TASKS_PATH = ".taskmaster/tasks/tasks.json";
+export const TASKS_SRC_PATH = ".taskmaster";
+export const TASKS_BCK_DEST_PATH = "backups/tmai-backup";
 
 // tasks
 export const MAIN_COMMAND = "task-master";
@@ -19,6 +21,13 @@ export const TASKS_STATUSES = [
 	"todo",
 	"blocked",
 ];
+export const TASKS_FILES = [
+	"windsurfrules",
+	".cursor",
+	".roo",
+	".roomodes",
+	".taskmaster",
+];
 export const DEFAULT_TAG = "master";
 export const DEFAULT_STATUS = "pending";
 export const DEFAULT_TASKS_TO_GENERATE = 10;

src/core/taskmaster/TaskMaster.ts

@@ -1,11 +1,12 @@
 /* libs */
 import { oraPromise } from "ora";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, writeFile, rm } from "node:fs/promises";
 import inquirer from "inquirer";
 import path from "node:path";
 import chalk from "chalk";
 import fs from "node:fs";
 import figures from "figures";
+import compressing from "compressing";
 
 /* constants */
 import {
@@ -14,6 +15,9 @@ import {
 	PACKAGE_MANAGERS,
 	TASKMASTER_INIT_MSG,
 	TASKS_FILE_WARN,
+	TASKS_BCK_DEST_PATH,
+	TASKS_SRC_PATH,
+	TASKS_FILES,
 } from "@/constants";
 
 /* extras */
@@ -595,4 +599,110 @@ export class TaskMaster {
 			].filter(Boolean),
 		);
 	}
+
+	// ==============================================
+	// Backup, Restore and Clear Methods
+	// ==============================================
+
+	// TODO: done
+	/**
+	 * @description Creates a backup of the .taskmaster directory
+	 * @param slot Slot number (1-3) for the backup
+	 */
+	public async backupAsync(slot: string): Promise<void> {
+		const backupPath = path.join(TASKS_BCK_DEST_PATH, `slot_${slot}.zip`);
+		const backupDir = path.dirname(backupPath);
+
+		if (!fs.existsSync(backupDir)) {
+			await mkdir(backupDir, { recursive: true });
+		}
+
+		// Vérifier si le répertoire source existe
+		if (!fs.existsSync(TASKS_SRC_PATH)) {
+			console.warn(
+				chalk.yellow(
+					`Source directory ${TASKS_SRC_PATH} does not exist. Skipping backup.`,
+				),
+			);
+			return;
+		}
+
+		const oraOptions = {
+			text: `Creating backup in slot ${slot}...`,
+			successText: chalk.bgGreen(
+				`Backup created successfully in slot ${slot}!`,
+			),
+			failText: chalk.bgRed(`Failed to create backup in slot ${slot}`),
+		};
+
+		await oraPromise(async () => {
+			await compressing.zip.compressDir(TASKS_SRC_PATH, backupPath);
+		}, oraOptions);
+	}
+
+	// TODO: done
+	/**
+	 * @description Restores a backup from the specified slot
+	 * @param slot Slot number (1-3) to restore from
+	 */
+	public async restoreAsync(slot: string): Promise<void> {
+		const backupPath = path.join(TASKS_BCK_DEST_PATH, `slot_${slot}.zip`);
+
+		if (!fs.existsSync(backupPath)) {
+			console.warn(
+				chalk.yellow(`No backup found in slot ${slot}. Skipping restore.`),
+			);
+			return;
+		}
+
+		const oraOptions = {
+			text: `Restoring backup from slot ${slot}...`,
+			successText: chalk.bgGreen(
+				`Backup restored successfully from slot ${slot}!`,
+			),
+			failText: chalk.bgRed(`Failed to restore backup from slot ${slot}`),
+		};
+
+		await oraPromise(async () => {
+			if (fs.existsSync(TASKS_SRC_PATH)) {
+				await rm(TASKS_SRC_PATH, { recursive: true, force: true });
+			}
+
+			const parentDir = path.dirname(TASKS_SRC_PATH);
+			if (!fs.existsSync(parentDir)) {
+				await mkdir(parentDir, { recursive: true });
+			}
+
+			await compressing.zip.uncompress(backupPath, parentDir);
+		}, oraOptions);
+	}
+
+	// TODO: done
+	/**
+	 * @description Clears all task-related files and directories
+	 */
+	public async clearTasksAsync(): Promise<void> {
+		for (const filePath of TASKS_FILES) {
+			if (!fs.existsSync(filePath)) continue;
+
+			const { confirm } = await inquirer.prompt({
+				type: "confirm",
+				name: "confirm",
+				message: chalk.red(`Delete ${filePath}?`),
+				default: false,
+			});
+
+			if (confirm) {
+				const oraOptions = {
+					text: `Deleting ${filePath}...`,
+					successText: chalk.bgGreen(`${filePath} deleted successfully!`),
+					failText: chalk.bgRed(`Failed to delete ${filePath}`),
+				};
+
+				await oraPromise(async () => {
+					await rm(filePath, { recursive: true, force: true });
+				}, oraOptions);
+			}
+		}
+	}
 }

src/core/taskmaster/asks.ts

@@ -1,6 +1,9 @@
 /* libs */
 import inquirer from "inquirer";
 import chalk from "chalk";
+import path from "node:path";
+import * as emoji from "node-emoji";
+import fs from "node:fs";
 
 /* constants */
 import {
@@ -21,8 +24,12 @@ import {
 	PRD_PATH,
 	TASKS_PRIORITIES,
 	TASKS_STATUSES,
+	TASKS_BCK_DEST_PATH,
 } from "@/constants";
 
+/* utils */
+import { existsAsync } from "@/utils/extras";
+
 // ===============================
 
 /**
@@ -326,6 +333,47 @@ export async function askNumSubtasks() {
 /**
  * @description Asks the user for manual subtask parameters
  */
+export async function askBackupSlot() {
+	const slots = [1, 2, 3];
+	const slotChoices = [];
+
+	for (const slot of slots) {
+		const backupPath = path.join(TASKS_BCK_DEST_PATH, `slot_${slot}.zip`);
+		const exists = await existsAsync(backupPath);
+
+		let slotInfo = "";
+		if (exists) {
+			const stats = fs.statSync(backupPath);
+			const date = new Date(stats.mtime);
+			const formattedDate = date.toLocaleDateString("fr-FR", {
+				day: "2-digit",
+				month: "2-digit",
+				year: "numeric",
+				hour: "2-digit",
+				minute: "2-digit",
+				second: "2-digit",
+			});
+			slotInfo = `${emoji.get("floppy_disk")} ${formattedDate}`;
+		} else {
+			slotInfo = `${emoji.get("open_file_folder")} Empty`;
+		}
+
+		slotChoices.push({
+			name: `Slot ${slot}: ${slotInfo}`,
+			value: slot.toString(),
+		});
+	}
+
+	const { selectedSlot } = await inquirer.prompt({
+		type: "list",
+		name: "selectedSlot",
+		message: "Choisissez un slot de sauvegarde :",
+		choices: slotChoices,
+	});
+
+	return selectedSlot;
+}
+
 export async function askSubtaskManualParams() {
 	return await inquirer.prompt([
 		{

src/core/taskmaster/exec.ts

@@ -28,8 +28,11 @@ import {
 	askSubtaskParentId,
 	askNumSubtasks,
 	askSubtaskManualParams,
+	askBackupSlot,
 } from "@/core/taskmaster/asks";
 
+import chalk from "chalk";
+
 /* prompt */
 import {
 	tmaiInitMenu_prompt,
@@ -40,6 +43,7 @@ import {
 	tmaiUpdateTasksMenu_prompt,
 	tmaiDeleteTasksMenu_prompt,
 	tmaiStatusTrackingMenu_prompt,
+	tmaiBackupRestoreClearClear_prompt,
 } from "@/prompt";
 
 // ===============================
@@ -244,3 +248,44 @@ export async function tmaiManageAsync() {
 
 	await restartAsync();
 }
+
+// TODO: done
+export async function tmaiBackupRestoreClearAsync() {
+	const { tmaiBackupRestoreClearMenu } = await inquirer.prompt(
+		tmaiBackupRestoreClearClear_prompt,
+	);
+
+	switch (tmaiBackupRestoreClearMenu) {
+		case "tmai-backup": {
+			const slot = await askBackupSlot();
+			await tmai.backupAsync(slot);
+			break;
+		}
+		case "tmai-restore": {
+			const slot = await askBackupSlot();
+			const { confirm } = await inquirer.prompt({
+				type: "confirm",
+				name: "confirm",
+				message: chalk.yellow(
+					`Are you sure you want to restore slot ${slot}? This will overwrite current data.`,
+				),
+				default: false,
+			});
+
+			if (confirm) {
+				await tmai.restoreAsync(slot);
+			} else {
+				console.log("Restore operation cancelled!");
+			}
+			break;
+		}
+		case "tmai-clear": {
+			await tmai.clearTasksAsync();
+			break;
+		}
+		default:
+			console.log("Invalid option selected.");
+	}
+
+	await restartAsync();
+}

src/index.ts

@@ -7,6 +7,7 @@ import {
 	tmaiInitAsync,
 	tmaiGenAsync,
 	tmaiManageAsync,
+	tmaiBackupRestoreClearAsync,
 } from "@/core/taskmaster/exec";
 
 /* utils */
@@ -58,6 +59,9 @@ export async function taskmasterCLI(): Promise<void> {
 		case "tmai-dev":
 			console.log("TM operations for development ...");
 			break;
+		case "tmai-bckrestore":
+			await tmaiBackupRestoreClearAsync();
+			break;
 		case "exit":
 			exitCLI();
 			break;

src/prompt.ts

@@ -41,6 +41,10 @@ export const mainMenu_prompt = [
 				value: "tmai-analysis",
 			},
 			new inquirer.Separator("―――――――――――――――――――――――――――――――――――"),
+			{
+				name: `${emoji.get("floppy_disk")} Backup, Restore and Clear`,
+				value: "tmai-bckrestore",
+			},
 			...(DEV_MODE
 				? [
 						{
@@ -387,7 +391,7 @@ export const tmaiDepsMenu_prompt = [
 export const tmaiAnalysisReportDocs_prompt = [
 	{
 		type: "list",
-		name: "tmaiAnalysisReportDocs",
+		name: "tmaiAnalysisReportDocsMenu",
 		message: chalk.bgBlue("Choose an operation"),
 		loop: true,
 		pageSize: 7,
@@ -408,3 +412,35 @@ export const tmaiAnalysisReportDocs_prompt = [
 		],
 	},
 ];
+
+// TODO: done
+// ==============================
+// Backup, Restore and Clear menu
+// ==============================
+
+export const tmaiBackupRestoreClearClear_prompt = [
+	{
+		type: "list",
+		name: "tmaiBackupRestoreClearMenu",
+		message: chalk.bgBlue("Choose an operation"),
+		loop: true,
+		pageSize: 5,
+		choices: [
+			new inquirer.Separator("=== Backup, Restore and Clear ==="),
+			{
+				name: chalk.blue(`${emoji.get("floppy_disk")} Backup tasks`),
+				value: "tmai-backup",
+			},
+			{
+				name: chalk.yellow(
+					`${emoji.get("arrows_counterclockwise")} Restore tasks`,
+				),
+				value: "tmai-restore",
+			},
+			{
+				name: chalk.red(`${emoji.get("boom")} Clear all current tasks`),
+				value: "tmai-clear",
+			},
+		],
+	},
+];