refactor: Add confirmation dialog for the cache clean command

Author: d3xter666

packages/cli/lib/cli/commands/cache.js

@@ -2,9 +2,10 @@ import chalk from "chalk";
 import path from "node:path";
 import os from "node:os";
 import process from "node:process";
+import readline from "node:readline";
 import baseMiddleware from "../middlewares/base.js";
 import Configuration from "@ui5/project/config/Configuration";
-import {cleanCache} from "@ui5/project/build/cache/CacheCleanup";
+import {cleanCache, getCacheInfo} from "@ui5/project/build/cache/CacheCleanup";
 
 const cacheCommand = {
 	command: "cache",
@@ -44,6 +45,26 @@ function formatSize(bytes) {
 	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
 
+/**
+ * Prompt user for confirmation.
+ *
+ * @param {string} question The question to ask
+ * @returns {Promise<boolean>} True if user confirmed
+ */
+async function confirm(question) {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+		});
+	});
+}
+
 async function handleCache() {
 	// Resolve UI5 data directory
 	let ui5DataDir = process.env.UI5_DATA_DIR;
@@ -57,20 +78,42 @@ async function handleCache() {
 		ui5DataDir = path.join(os.homedir(), ".ui5");
 	}
 
-	const result = await cleanCache({ui5DataDir});
+	// Check what items exist before cleaning
+	const items = await getCacheInfo({ui5DataDir});
 
-	if (result.totalCount === 0) {
+	if (items.length === 0) {
 		process.stderr.write("Nothing to clean\n");
 		return;
 	}
 
+	// Display items that will be removed
+	process.stderr.write(chalk.bold("\nThe following items from cache will be removed:\n"));
+	let totalSize = 0;
+	for (const item of items) {
+		totalSize += item.size;
+		const sizeStr = item.size > 0 ? ` (${formatSize(item.size)})` : "";
+		process.stderr.write(`  ${chalk.yellow("•")} ${item.path}${sizeStr}\n`);
+	}
+	process.stderr.write(chalk.bold(`\nTotal: ${formatSize(totalSize)}\n\n`));
+
+	// Ask for confirmation
+	const confirmed = await confirm("Do you want to continue? (y/N) ");
+	if (!confirmed) {
+		process.stderr.write("Cancelled\n");
+		return;
+	}
+
+	// Perform the actual cleanup
+	const result = await cleanCache({ui5DataDir});
+
+	process.stderr.write("\n");
 	for (const entry of result.entries) {
 		const sizeStr = entry.size > 0 ? ` (${formatSize(entry.size)})` : "";
-		process.stderr.write(`Removed ${chalk.bold(entry.path)}${sizeStr}\n`);
+		process.stderr.write(`${chalk.green("✓")} Removed ${chalk.bold(entry.path)}${sizeStr}\n`);
 	}
 
 	process.stderr.write(
-		`\nCleaned ${result.totalCount} ${result.totalCount === 1 ? "entry" : "entries"}` +
+		`\n${chalk.green("Success:")} Cleaned ${result.totalCount} ${result.totalCount === 1 ? "entry" : "entries"}` +
 		(result.totalSize > 0 ? `, freed ${formatSize(result.totalSize)}` : "") + "\n"
 	);
 }

packages/cli/test/lib/cli/commands/cache.js

@@ -24,11 +24,24 @@ test.beforeEach(async (t) => {
 	sinon.stub(Configuration, "fromFile").resolves(new Configuration({}));
 
 	t.context.cleanCacheStub = sinon.stub();
+	t.context.getCacheInfoStub = sinon.stub();
+
+	// Mock readline to simulate user confirmation
+	const mockRLInterface = {
+		question: sinon.stub(),
+		close: sinon.stub()
+	};
+	t.context.readlineCreateInterfaceStub = sinon.stub().returns(mockRLInterface);
+	t.context.mockRLInterface = mockRLInterface;
 
 	t.context.cache = await esmock.p("../../../../lib/cli/commands/cache.js", {
 		"@ui5/project/config/Configuration": t.context.Configuration,
 		"@ui5/project/build/cache/CacheCleanup": {
 			cleanCache: t.context.cleanCacheStub,
+			getCacheInfo: t.context.getCacheInfoStub,
+		},
+		"node:readline": {
+			createInterface: t.context.readlineCreateInterfaceStub,
 		},
 	});
 });
@@ -38,24 +51,53 @@ test.afterEach.always((t) => {
 	esmock.purge(t.context.cache);
 });
 
+test("Command builder", async (t) => {
+	// Import cache module directly for builder test (before beforeEach stubs are created)
+	const cacheModule = await import("../../../../lib/cli/commands/cache.js");
+	const cliStub = {
+		demandCommand: sinon.stub().returnsThis(),
+		command: sinon.stub().returnsThis(),
+		example: sinon.stub().returnsThis(),
+	};
+	const result = cacheModule.default.builder(cliStub);
+	t.is(result, cliStub, "Builder returns cli instance");
+	t.is(cliStub.demandCommand.callCount, 1, "demandCommand called once");
+	t.is(cliStub.command.callCount, 1, "command called once");
+	t.is(cliStub.example.callCount, 1, "example called once");
+});
+
 test.serial("ui5 cache clean: nothing to clean", async (t) => {
-	const {cache, argv, stderrWriteStub, cleanCacheStub} = t.context;
+	const {cache, argv, stderrWriteStub, cleanCacheStub, getCacheInfoStub} = t.context;
 
-	cleanCacheStub.resolves({entries: [], totalSize: 0, totalCount: 0});
+	// Simulate no cache items
+	getCacheInfoStub.resolves([]);
 
 	argv["_"] = ["cache", "clean"];
 	await cache.handler(argv);
 
 	t.is(stderrWriteStub.firstCall.firstArg, "Nothing to clean\n");
+	t.is(cleanCacheStub.callCount, 0, "cleanCache should not be called");
 });
 
 test.serial("ui5 cache clean: removes entries and reports", async (t) => {
-	const {cache, argv, stderrWriteStub, cleanCacheStub} = t.context;
+	const {cache, argv, stderrWriteStub, cleanCacheStub, getCacheInfoStub,
+		mockRLInterface} = t.context;
+
+	// Simulate existing cache items
+	getCacheInfoStub.resolves([
+		{path: "framework/", size: 15 * 1024 * 1024, type: "directory"},
+		{path: "buildCache/ (database records)", size: 8 * 1024 * 1024, type: "database"},
+	]);
+
+	// Mock user confirmation
+	mockRLInterface.question.callsFake((question, callback) => {
+		callback("y");
+	});
 
 	cleanCacheStub.resolves({
 		entries: [
-			{path: "@openui5/sap.ui.core/1.120.0", type: "framework", size: 15 * 1024 * 1024},
-			{path: "@openui5/sap.m/1.120.0", type: "framework", size: 8 * 1024 * 1024},
+			{path: "framework", type: "framework", size: 15 * 1024 * 1024},
+			{path: "buildCache", type: "buildCache", size: 8 * 1024 * 1024},
 		],
 		totalSize: 23 * 1024 * 1024,
 		totalCount: 2,
@@ -64,18 +106,156 @@ test.serial("ui5 cache clean: removes entries and reports", async (t) => {
 	argv["_"] = ["cache", "clean"];
 	await cache.handler(argv);
 
-	// Should have 4 writes: 2 entries + 1 newline + summary
-	t.true(stderrWriteStub.callCount >= 3, "Multiple lines written to stderr");
-	// Check that summary mentions entries count
+	// Check that confirmation was asked
+	t.is(mockRLInterface.question.callCount, 1, "Should ask for confirmation");
+	t.true(mockRLInterface.question.firstCall.args[0].includes("continue"),
+		"Confirmation question should ask to continue");
+
+	// Check that cleanCache was called
+	t.is(cleanCacheStub.callCount, 1, "cleanCache should be called once");
+
+	// Check output
 	const allOutput = stderrWriteStub.args.map((a) => a[0]).join("");
+	t.true(allOutput.includes("following items from cache will be removed"), "Shows items to be removed");
 	t.true(allOutput.includes("2 entries"), "Summary mentions entry count");
-	t.true(allOutput.includes("23.0 MB"), "Summary mentions freed size");
+	t.true(allOutput.includes("Success"), "Shows success message");
 });
 
-test("Command definition is correct", (t) => {
+test.serial("ui5 cache clean: user cancels", async (t) => {
+	const {cache, argv, stderrWriteStub, cleanCacheStub, getCacheInfoStub,
+		mockRLInterface} = t.context;
+
+	// Simulate existing cache items
+	getCacheInfoStub.resolves([
+		{path: "framework/", size: 5 * 1024 * 1024, type: "directory"}
+	]);
+
+	// Mock user cancellation
+	mockRLInterface.question.callsFake((question, callback) => {
+		callback("n");
+	});
+
+	argv["_"] = ["cache", "clean"];
+	await cache.handler(argv);
+
+	// Check that confirmation was asked
+	t.is(mockRLInterface.question.callCount, 1, "Should ask for confirmation");
+
+	// Check that cleanCache was NOT called
+	t.is(cleanCacheStub.callCount, 0, "cleanCache should not be called when user cancels");
+
+	// Check output
+	const allOutput = stderrWriteStub.args.map((a) => a[0]).join("");
+	t.true(allOutput.includes("following items from cache will be removed"), "Shows items to be removed");
+	t.true(allOutput.includes("Cancelled"), "Shows cancelled message");
+	t.false(allOutput.includes("Success"), "Should not show success message");
+});
+
+test.serial("Command definition is correct", (t) => {
 	// Import without esmock for structure check
 	t.is(t.context.cache.command, "cache");
 	t.is(t.context.cache.describe, "Manage UI5 CLI cache");
 	t.is(typeof t.context.cache.builder, "function");
 	t.is(typeof t.context.cache.handler, "function");
 });
+
+test.serial("ui5 cache clean: accepts 'yes' as confirmation", async (t) => {
+	const {cache, argv, cleanCacheStub, getCacheInfoStub, mockRLInterface} = t.context;
+
+	getCacheInfoStub.resolves([
+		{path: "framework/", size: 1024, type: "directory"}
+	]);
+
+	mockRLInterface.question.callsFake((question, callback) => {
+		callback("yes");
+	});
+
+	cleanCacheStub.resolves({
+		entries: [{path: "framework", type: "framework", size: 1024}],
+		totalSize: 1024,
+		totalCount: 1,
+	});
+
+	argv["_"] = ["cache", "clean"];
+	await cache.handler(argv);
+
+	t.is(cleanCacheStub.callCount, 1, "cleanCache should be called with 'yes' confirmation");
+});
+
+test.serial("ui5 cache clean: formats byte sizes correctly", async (t) => {
+	const {cache, argv, stderrWriteStub, cleanCacheStub, getCacheInfoStub, mockRLInterface} = t.context;
+
+	// Test with small bytes (B), KB, and GB sizes
+	getCacheInfoStub.resolves([
+		{path: "small", size: 512, type: "directory"}, // < 1024 = B
+		{path: "medium", size: 50 * 1024, type: "directory"}, // KB
+		{path: "large", size: 2 * 1024 * 1024 * 1024, type: "directory"}, // GB
+	]);
+
+	mockRLInterface.question.callsFake((question, callback) => {
+		callback("y");
+	});
+
+	cleanCacheStub.resolves({
+		entries: [
+			{path: "small", type: "directory", size: 512},
+			{path: "medium", type: "directory", size: 50 * 1024},
+			{path: "large", type: "directory", size: 2 * 1024 * 1024 * 1024},
+		],
+		totalSize: 2 * 1024 * 1024 * 1024 + 50 * 1024 + 512,
+		totalCount: 3,
+	});
+
+	argv["_"] = ["cache", "clean"];
+	await cache.handler(argv);
+
+	const allOutput = stderrWriteStub.args.map((a) => a[0]).join("");
+	t.true(allOutput.includes("512 B"), "Shows bytes format");
+	t.true(allOutput.includes("50.0 KB"), "Shows KB format");
+	t.true(allOutput.includes("2.0 GB"), "Shows GB format");
+});
+
+test.serial("ui5 cache clean: uses UI5_DATA_DIR from environment", async (t) => {
+	const {cache, argv, getCacheInfoStub} = t.context;
+	const originalEnv = process.env.UI5_DATA_DIR;
+
+	try {
+		process.env.UI5_DATA_DIR = "/custom/ui5/path";
+
+		getCacheInfoStub.resolves([]);
+
+		argv["_"] = ["cache", "clean"];
+		await cache.handler(argv);
+
+		t.is(getCacheInfoStub.callCount, 1, "getCacheInfo called");
+		t.true(getCacheInfoStub.firstCall.args[0].ui5DataDir.includes("custom/ui5/path"),
+			"Uses environment variable path");
+	} finally {
+		if (originalEnv) {
+			process.env.UI5_DATA_DIR = originalEnv;
+		} else {
+			delete process.env.UI5_DATA_DIR;
+		}
+	}
+});
+
+test.serial("ui5 cache clean: uses config.getUi5DataDir when no env var", async (t) => {
+	const {cache, argv, getCacheInfoStub, Configuration} = t.context;
+	const originalEnv = process.env.UI5_DATA_DIR;
+
+	try {
+		delete process.env.UI5_DATA_DIR;
+
+		Configuration.fromFile.resolves(new Configuration({ui5DataDir: "/config/path"}));
+		getCacheInfoStub.resolves([]);
+
+		argv["_"] = ["cache", "clean"];
+		await cache.handler(argv);
+
+		t.is(getCacheInfoStub.callCount, 1, "getCacheInfo called");
+	} finally {
+		if (originalEnv) {
+			process.env.UI5_DATA_DIR = originalEnv;
+		}
+	}
+});

packages/project/lib/build/cache/BuildCacheStorage.js

@@ -576,6 +576,21 @@ export default class BuildCacheStorage {
 		return bytesBefore - bytesAfter;
 	}
 
+	/**
+	 * Checks if the database has any records in any table.
+	 *
+	 * @returns {boolean} True if there are any records
+	 */
+	hasRecords() {
+		const tables = ["content", "index_cache", "stage_metadata", "task_metadata", "result_metadata"];
+		for (const table of tables) {
+			const count = this.#db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get()?.count ?? 0;
+			if (count > 0) {
+				return true;
+			}
+		}
+		return false;
+	}
 	/**
 	 * Closes the database connection
 	 */