@meltstudio/meltctl 2.1.0 → 2.2.0

package/README.md

@@ -70,6 +70,18 @@ Updates your project templates to the latest version. This command:
 - Verifies .melt/ workspace migration status
 - Handles version compatibility automatically
 
+### Clean Project
+
+```bash
+meltctl project clean
+```
+
+Safely removes all Melt-generated files from your project while preserving user-created content. This command:
+- Removes the entire `.melt/` directory (all Melt-generated content)
+- Selectively removes only Melt commands from `.cursor/commands/`
+- Preserves user-created files in `.cursor/commands/`
+- Provides interactive confirmation before deletion
+
 ## 🛠️ Requirements
 
 - Node.js 22+ (works with Node.js 18+ but 22+ recommended)

package/dist/commands/project/clean.d.ts

@@ -0,0 +1,5 @@
+interface CleanOptions {
+    placeholder?: never;
+}
+export declare function cleanCommand(_options?: CleanOptions): Promise<void>;
+export {};

package/dist/commands/project/clean.js

@@ -0,0 +1,239 @@
+import { intro, outro, confirm, spinner } from '@clack/prompts';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+// List of Melt-generated command files to remove
+const MELT_COMMAND_FILES = [
+    'melt-plan.md',
+    'melt-test-plan.md',
+    'melt-docs.md',
+    'melt-implement.md',
+    'melt-pr.md',
+    'melt-review.md',
+    'melt-complete.md',
+    'melt-debug.md',
+];
+export async function cleanCommand(_options = {}) {
+    intro(chalk.blue('🧹 Melt Project - Clean'));
+    const currentDir = process.cwd();
+    const meltDir = path.join(currentDir, '.melt');
+    const cursorCommandsDir = path.join(currentDir, '.cursor', 'commands');
+    // Check if this is a Melt workspace
+    const hasMeltWorkspace = await fs.pathExists(meltDir);
+    const hasCursorCommands = await fs.pathExists(cursorCommandsDir);
+    if (!hasMeltWorkspace && !hasCursorCommands) {
+        console.log(chalk.yellow('⚠️  No Melt workspace found in this directory.'));
+        console.log("This project doesn't appear to have Melt tools installed.");
+        outro(chalk.gray('Nothing to clean.'));
+        return;
+    }
+    // Analyze what will be cleaned
+    const analysisResult = await analyzeCleanupTarget(currentDir);
+    if (analysisResult.removedFiles.length === 0 && analysisResult.removedDirs.length === 0) {
+        console.log(chalk.yellow('⚠️  No Melt files found to clean.'));
+        outro(chalk.gray('Nothing to clean.'));
+        return;
+    }
+    // Show what will be cleaned
+    displayCleanupPlan(analysisResult);
+    // Get confirmation
+    const shouldProceed = await confirm({
+        message: 'Do you want to proceed with cleaning? This action cannot be undone.',
+    });
+    if (!shouldProceed) {
+        outro(chalk.gray('Clean operation cancelled.'));
+        return;
+    }
+    // Perform the cleanup
+    const s = spinner();
+    s.start('Cleaning Melt workspace...');
+    try {
+        const cleanResult = await performCleanup(currentDir);
+        s.stop('✅ Cleanup completed!');
+        displayCleanupResults(cleanResult);
+        outro(chalk.green('🎉 Melt workspace cleaned successfully!'));
+    }
+    catch (error) {
+        s.stop('❌ Cleanup failed');
+        console.error(chalk.red('Error during cleanup:'), error);
+        process.exit(1);
+    }
+}
+async function analyzeCleanupTarget(baseDir) {
+    const result = {
+        removedFiles: [],
+        removedDirs: [],
+        preservedFiles: [],
+        errors: [],
+    };
+    const meltDir = path.join(baseDir, '.melt');
+    const cursorCommandsDir = path.join(baseDir, '.cursor', 'commands');
+    try {
+        // Check .melt directory (remove entirely)
+        if (await fs.pathExists(meltDir)) {
+            result.removedDirs.push('.melt/');
+        }
+        // Check .cursor/commands directory (selective removal)
+        if (await fs.pathExists(cursorCommandsDir)) {
+            const commandFiles = await fs.readdir(cursorCommandsDir);
+            for (const file of commandFiles) {
+                const filePath = path.join(cursorCommandsDir, file);
+                const stat = await fs.stat(filePath);
+                if (stat.isFile()) {
+                    if (MELT_COMMAND_FILES.includes(file)) {
+                        result.removedFiles.push(path.join('.cursor/commands', file));
+                    }
+                    else {
+                        result.preservedFiles.push(path.join('.cursor/commands', file));
+                    }
+                }
+            }
+            // Check if .cursor/commands will be empty after cleaning
+            const meltFiles = commandFiles.filter(file => MELT_COMMAND_FILES.includes(file));
+            const nonMeltFiles = commandFiles.filter(file => !MELT_COMMAND_FILES.includes(file));
+            if (meltFiles.length > 0 && nonMeltFiles.length === 0) {
+                result.removedDirs.push('.cursor/commands/');
+                // Also check if .cursor itself would be empty
+                const cursorDir = path.join(baseDir, '.cursor');
+                const cursorContents = await fs.readdir(cursorDir);
+                if (cursorContents.length === 1 && cursorContents[0] === 'commands') {
+                    result.removedDirs.push('.cursor/');
+                }
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to analyze cleanup target: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+async function performCleanup(baseDir) {
+    const result = {
+        removedFiles: [],
+        removedDirs: [],
+        preservedFiles: [],
+        errors: [],
+    };
+    const meltDir = path.join(baseDir, '.melt');
+    const cursorCommandsDir = path.join(baseDir, '.cursor', 'commands');
+    try {
+        // Remove .melt directory entirely
+        if (await fs.pathExists(meltDir)) {
+            await fs.remove(meltDir);
+            result.removedDirs.push('.melt/');
+        }
+        // Remove Melt command files from .cursor/commands
+        if (await fs.pathExists(cursorCommandsDir)) {
+            const commandFiles = await fs.readdir(cursorCommandsDir);
+            let hasNonMeltFiles = false;
+            for (const file of commandFiles) {
+                const filePath = path.join(cursorCommandsDir, file);
+                const stat = await fs.stat(filePath);
+                if (stat.isFile()) {
+                    if (MELT_COMMAND_FILES.includes(file)) {
+                        try {
+                            await fs.remove(filePath);
+                            result.removedFiles.push(path.join('.cursor/commands', file));
+                        }
+                        catch (error) {
+                            result.errors.push(`Failed to remove ${file}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    else {
+                        hasNonMeltFiles = true;
+                        result.preservedFiles.push(path.join('.cursor/commands', file));
+                    }
+                }
+            }
+            // Remove empty directories if no user files remain
+            if (!hasNonMeltFiles) {
+                try {
+                    await fs.remove(cursorCommandsDir);
+                    result.removedDirs.push('.cursor/commands/');
+                    // Check if .cursor directory is now empty
+                    const cursorDir = path.join(baseDir, '.cursor');
+                    if (await fs.pathExists(cursorDir)) {
+                        const cursorContents = await fs.readdir(cursorDir);
+                        if (cursorContents.length === 0) {
+                            await fs.remove(cursorDir);
+                            result.removedDirs.push('.cursor/');
+                        }
+                    }
+                }
+                catch (error) {
+                    result.errors.push(`Failed to remove empty directories: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+function displayCleanupPlan(result) {
+    console.log();
+    console.log(chalk.cyan('📋 Cleanup Plan:'));
+    console.log();
+    if (result.removedDirs.length > 0) {
+        console.log(chalk.yellow('Directories to be removed:'));
+        result.removedDirs.forEach(dir => {
+            console.log(`  • ${chalk.red(dir)}`);
+        });
+        console.log();
+    }
+    if (result.removedFiles.length > 0) {
+        console.log(chalk.yellow('Files to be removed:'));
+        result.removedFiles.forEach(file => {
+            console.log(`  • ${chalk.red(file)}`);
+        });
+        console.log();
+    }
+    if (result.preservedFiles.length > 0) {
+        console.log(chalk.green('Files to be preserved:'));
+        result.preservedFiles.forEach(file => {
+            console.log(`  • ${chalk.cyan(file)}`);
+        });
+        console.log();
+    }
+    if (result.errors.length > 0) {
+        console.log(chalk.red('Analysis errors:'));
+        result.errors.forEach(error => {
+            console.log(`  ⚠️  ${error}`);
+        });
+        console.log();
+    }
+}
+function displayCleanupResults(result) {
+    console.log();
+    console.log(chalk.green('🎯 Cleanup Summary:'));
+    console.log();
+    if (result.removedDirs.length > 0) {
+        console.log(chalk.green(`✅ Removed ${result.removedDirs.length} directories:`));
+        result.removedDirs.forEach(dir => {
+            console.log(`   • ${dir}`);
+        });
+        console.log();
+    }
+    if (result.removedFiles.length > 0) {
+        console.log(chalk.green(`✅ Removed ${result.removedFiles.length} files:`));
+        result.removedFiles.forEach(file => {
+            console.log(`   • ${file}`);
+        });
+        console.log();
+    }
+    if (result.preservedFiles.length > 0) {
+        console.log(chalk.cyan(`🔒 Preserved ${result.preservedFiles.length} user files:`));
+        result.preservedFiles.forEach(file => {
+            console.log(`   • ${file}`);
+        });
+        console.log();
+    }
+    if (result.errors.length > 0) {
+        console.log(chalk.red(`❌ Errors encountered (${result.errors.length}):`));
+        result.errors.forEach(error => {
+            console.log(`   • ${error}`);
+        });
+        console.log();
+    }
+}

package/dist/index.js

@@ -5,6 +5,7 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { initCommand } from './commands/project/init.js';
 import { updateCommand } from './commands/project/update.js';
+import { cleanCommand } from './commands/project/clean.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -34,4 +35,10 @@ projectCommand
     .command('update')
     .description('Update project configurations to latest version')
     .action(updateCommand);
+projectCommand
+    .command('clean')
+    .description('Remove all Melt-generated files from the project')
+    .action(() => {
+    return cleanCommand();
+});
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "CLI tool for Melt development process automation - initialize and update project configurations",
   "main": "dist/index.js",
   "type": "module",