aiwcli 0.15.5 → 0.17.0

package/dist/capabilities/installation/control-plane/clean-command.js

@@ -0,0 +1,196 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import confirm from '@inquirer/confirm';
+import { Flags } from '@oclif/core';
+import BaseCommand from '../../../cli/base-command.js';
+import { EXIT_CODES } from '../../../types/exit-codes.js';
+/**
+ * Clean output folder(s) for methods.
+ * Removes all files and subdirectories from the method's output folder.
+ */
+export default class CleanCommand extends BaseCommand {
+    static description = 'Clean output folder(s) for a specific method or all methods';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --method cc-native',
+        '<%= config.bin %> <%= command.id %> -m cc-native',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> -a --dry-run',
+        '<%= config.bin %> <%= command.id %> --method cc-native --dry-run',
+        '<%= config.bin %> <%= command.id %> -m cc-native --force',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        all: Flags.boolean({
+            char: 'a',
+            description: 'Clean all output folders',
+            default: false,
+            exclusive: ['method'],
+        }),
+        'dry-run': Flags.boolean({
+            char: 'n',
+            description: 'Show what would be deleted without actually deleting',
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        method: Flags.string({
+            char: 'm',
+            description: 'Method name whose output folder to clean (e.g., cc-native)',
+            exclusive: ['all'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(CleanCommand);
+        const targetDir = process.cwd();
+        this.logWarning("'aiw clean' is deprecated. Use 'aiw clear --output' instead.");
+        // Validate: require either --method or --all
+        if (!flags.method && !flags.all) {
+            this.error('Either --method or --all is required.', {
+                exit: EXIT_CODES.GENERAL_ERROR,
+            });
+        }
+        try {
+            // Find output folders to clean
+            const outputFolders = flags.all
+                ? await this.findAllOutputFolders(targetDir)
+                : [`_${flags.method}-output`];
+            if (outputFolders.length === 0) {
+                this.logInfo('No output folders found.');
+                return;
+            }
+            // Collect contents from all folders (parallel stat and content retrieval)
+            const folderResults = await Promise.all(outputFolders.map(async (folder) => {
+                const folderPath = join(targetDir, folder);
+                const stat = await fs.stat(folderPath).catch(() => null);
+                if (!stat?.isDirectory()) {
+                    return { folder, items: [], exists: false };
+                }
+                const items = await this.getContents(folderPath);
+                return { folder, items, exists: true };
+            }));
+            // Check for non-existent folder in single method mode
+            if (!flags.all) {
+                const result = folderResults[0];
+                if (result && !result.exists) {
+                    this.logInfo(`Output folder '${result.folder}' does not exist.`);
+                    return;
+                }
+            }
+            // Filter to folders with content
+            const allContents = folderResults.filter((r) => r.exists && r.items.length > 0);
+            const totalItems = allContents.reduce((sum, c) => sum + c.items.length, 0);
+            if (totalItems === 0) {
+                const msg = flags.all ? 'All output folders are empty.' : `Output folder '${outputFolders[0]}' is already empty.`;
+                this.logInfo(msg);
+                return;
+            }
+            // Show what will be deleted
+            this.log('');
+            this.logInfo(`Found ${totalItems} item(s) in ${allContents.length} output folder(s):`);
+            this.log('');
+            this.displayContents(allContents, targetDir);
+            this.log('');
+            // Dry run - just show files without deleting
+            if (flags['dry-run']) {
+                this.logInfo('Dry run complete. No files were deleted.');
+                return;
+            }
+            // Confirm deletion
+            if (!flags.force) {
+                const folderNames = allContents.map((c) => c.folder).join(', ');
+                const shouldDelete = await confirm({
+                    message: `Delete all contents of ${allContents.length > 1 ? 'folders: ' : ''}${folderNames}?`,
+                    default: false,
+                });
+                if (!shouldDelete) {
+                    this.log('Operation cancelled.');
+                    return;
+                }
+            }
+            // Delete all contents (parallel deletion with error tracking)
+            const allItems = allContents.flatMap((c) => c.items);
+            const deleteResults = await Promise.all(allItems.map(async (item) => {
+                try {
+                    await fs.rm(item.path, { recursive: true, force: true });
+                    this.logDebug(`Deleted: ${item.path}`);
+                    return { success: true, path: item.path };
+                }
+                catch (error) {
+                    const err = error;
+                    this.logWarning(`Failed to delete ${item.path}: ${err.message}`);
+                    return { success: false, path: item.path };
+                }
+            }));
+            const deletedCount = deleteResults.filter((r) => r.success).length;
+            this.log('');
+            const firstFolder = allContents[0];
+            const folderSummary = allContents.length === 1 && firstFolder ? `'${firstFolder.folder}'` : `${allContents.length} folders`;
+            this.logSuccess(`Cleaned ${folderSummary}: ${deletedCount} item(s) deleted.`);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'EACCES' || err.code === 'EPERM') {
+                this.error(`Permission denied. ${err.message}`, {
+                    exit: EXIT_CODES.ENVIRONMENT_ERROR,
+                });
+            }
+            this.error(`Clean failed: ${err.message}`, {
+                exit: EXIT_CODES.GENERAL_ERROR,
+            });
+        }
+    }
+    /**
+     * Display contents of folders that will be deleted.
+     *
+     * @param allContents - Folders with their contents
+     * @param targetDir - Base directory for relative path display
+     */
+    displayContents(allContents, targetDir) {
+        for (const { items } of allContents) {
+            for (const item of items) {
+                const relativePath = item.path.replace(targetDir + '\\', '').replace(targetDir + '/', '');
+                const suffix = item.isDirectory ? '/' : '';
+                this.log(`  ${relativePath}${suffix}`);
+            }
+        }
+    }
+    /**
+     * Find all output folders in the target directory.
+     * Matches folders with pattern _*-output (e.g., _bmad-output, _gsd-output).
+     *
+     * @param targetDir - Directory to search in
+     * @returns Array of output folder names
+     */
+    async findAllOutputFolders(targetDir) {
+        try {
+            const entries = await fs.readdir(targetDir, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('_') && entry.name.endsWith('-output'))
+                .map((entry) => entry.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get all top-level contents of a directory.
+     *
+     * @param dirPath - Directory to list contents of
+     * @returns Array of content items with path and type info
+     */
+    async getContents(dirPath) {
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            return entries.map((entry) => ({
+                isDirectory: entry.isDirectory(),
+                path: join(dirPath, entry.name),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/capabilities/installation/control-plane/clear-command.d.ts

@@ -0,0 +1,162 @@
+import BaseCommand from '../../../cli/base-command.js';
+export declare const PROTECTED_OUTPUT_DIRS: Set<string>;
+/**
+ * Clear method runtime folders, output folders, IDE method folders, and update configurations.
+ */
+export default class ClearCommand extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        template: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Clean runtime output artifacts from _output/ at project root.
+     * Handles temp files, cache files, log rotation, and archive cleanup.
+     *
+     * @param targetDir - Project root directory
+     * @param flags - Command flags (dry-run, force)
+     * @param flags.force - Skip confirmation prompt
+     */
+    private cleanRuntimeOutput;
+    /**
+     * Clean up backup files created during settings reconstruction.
+     *
+     * @param targetDir - Project root directory
+     */
+    private cleanupBackupFiles;
+    /**
+     * Clean up git exclude entries and prune stale entries.
+     *
+     * @param targetDir - Project root directory
+     * @returns True if git exclude was updated
+     */
+    private cleanupGitExclude;
+    private countCoreIdeManagedFiles;
+    private countMatchingManagedFiles;
+    /**
+     * Display a list of folders to remove.
+     *
+     * @param targetDir - Base directory for relative path display
+     * @param folders - Array of folder paths
+     * @param label - Label for the folder type
+     */
+    private displayFolderList;
+    /**
+     * Display all pending changes before confirmation.
+     *
+     * @param targetDir - Project root directory
+     * @param folders - Discovered folders and methods to remove
+     * @param folders.methodRuntimeFolders - Method runtime folders to remove
+     * @param folders.outputMethodFolders - Output method folders to remove
+     * @param folders.ideMethodFolders - IDE method folders to remove
+     * @param folders.coreRuntimeFolders - Core runtime folders to remove
+     * @param folders.coreIdeFilesToRemove - Number of core IDE files to remove
+     * @param folders.methodsToRemove - Method names being removed
+     */
+    private displayPendingChanges;
+    /**
+     * Delete all discovered folders in parallel.
+     *
+     * @param methodRuntimeFolders - Method runtime folders to delete
+     * @param outputMethodFolders - Output method folders to delete
+     * @param ideMethodFolders - IDE method folders to delete
+     * @returns Count of successfully deleted folders by type
+     */
+    private executeFolderDeletion;
+    /**
+     * Extract method names from runtime folder names (e.g., _gsd -> gsd).
+     *
+     * @param methodRuntimeFolders - Array of runtime folder paths
+     * @returns Array of method names
+     */
+    private extractMethodNames;
+    private findCoreRuntimeFolders;
+    /**
+     * Find all IDE method folders by scanning subdirectories of each IDE root
+     * for children matching installed method names.
+     *
+     * For example, finds .claude/commands/cc-native/, .claude/skills/cc-native/,
+     * .windsurf/workflows/cc-native/ — without hardcoding which subdirectories exist.
+     *
+     * @param targetDir - Directory to search in
+     * @param template - Optional template/method name to filter by
+     * @returns Array of IDE method folder paths
+     */
+    private findIdeMethodFolders;
+    /**
+     * Find all method runtime folders in the target directory.
+     * Looks for .aiwcli/_{method}/ structure (e.g., .aiwcli/_gsd/, .aiwcli/_bmad/).
+     *
+     * @param targetDir - Directory to search in
+     * @param template - Optional template/method name to filter by (e.g., 'bmad', 'gsd')
+     * @returns Array of method runtime folder paths
+     */
+    private findMethodRuntimeFolders;
+    /**
+     * Find all method output folders in the target directory.
+     * Looks for _output/{method}/ structure at project root.
+     *
+     * @param targetDir - Directory to search in
+     * @param template - Optional template/method name to filter by (e.g., 'bmad', 'gsd')
+     * @returns Array of output folder paths
+     */
+    private findOutputFolders;
+    private getCoreTemplatePathSafe;
+    /**
+     * Perform all post-deletion cleanup: empty dir removal, git exclude, settings, IDE folders.
+     *
+     * @param targetDir - Project root directory
+     * @param methodsToRemove - Method names being removed
+     * @returns Cleanup result state
+     */
+    private performPostDeleteCleanup;
+    /**
+     * Reconstruct IDE settings after method removal.
+     *
+     * @param targetDir - Project root directory
+     * @param methodsToRemove - Methods being removed
+     * @returns Which IDE settings were updated
+     */
+    private reconstructSettingsAfterRemoval;
+    private removeCoreIdeContent;
+    /**
+     * Report the results of a clear operation.
+     *
+     * @param deleteCounts - Counts of deleted folders by type
+     * @param deleteCounts.deletedMethodRuntime - Number of method runtime folders deleted
+     * @param deleteCounts.deletedOutput - Number of output folders deleted
+     * @param deleteCounts.deletedIde - Number of IDE method folders deleted
+     * @param deleteCounts.deletedCoreRuntime - Number of core runtime folders deleted
+     * @param cleanup - Cleanup operation results
+     * @param cleanup.gitExcludeUpdated - Whether git exclude was updated
+     * @param cleanup.removedOutputDir - Whether _output dir was removed
+     * @param cleanup.removedAiwcliContainer - Whether .aiwcli dir was removed
+     * @param cleanup.removedClaudeDir - Whether .claude dir was removed
+     * @param cleanup.removedCodexDir - Whether .codex dir was removed
+     * @param cleanup.removedDevinDir - Whether .devin dir was removed
+     * @param cleanup.removedWindsurfDir - Whether .windsurf dir was removed
+     * @param cleanup.removedCoreIdeFiles - Number of core IDE files removed
+     * @param cleanup.updatedClaudeSettings - Whether Claude settings were updated
+     * @param cleanup.updatedWindsurfSettings - Whether Windsurf settings were updated
+     */
+    private reportClearResults;
+    private resolveMethodsToRemove;
+    private stripAiwSettingsForFullClear;
+    /**
+     * Try to remove an IDE folder if it should be deleted (empty settings + empty subfolders).
+     *
+     * @param targetDir - Project root directory
+     * @param ideFolder - IDE folder configuration
+     * @param ideFolder.root - Root folder name (e.g., '.claude')
+     * @param ideFolder.settingsFile - Settings file name (e.g., 'settings.json')
+     * @returns True if the folder was removed
+     */
+    private tryRemoveIdeFolder;
+}