aiwcli 0.10.2 → 0.11.0

package/dist/commands/clear.js

@@ -3,8 +3,9 @@ import { join } from 'node:path';
 import { confirm } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import BaseCommand from '../lib/base-command.js';
-import { pruneGitignoreStaleEntries } from '../lib/gitignore-manager.js';
+import { computeGitignoreRemovals, pruneGitignoreStaleEntries, removeGitignoreEntries } from '../lib/gitignore-manager.js';
 import { pathExists } from '../lib/paths.js';
+import { reconstructIdeSettings } from '../lib/template-settings-reconstructor.js';
 import { EXIT_CODES } from '../types/exit-codes.js';
 /**
  * Container folder for method-specific files
@@ -43,6 +44,7 @@ async function getInstalledMethodNames(targetDir) {
     for (const ide of Object.values(IDE_FOLDERS)) {
         const settingsPath = join(targetDir, ide.root, ide.settingsFile);
         try {
+            // eslint-disable-next-line no-await-in-loop
             const content = await fs.readFile(settingsPath, 'utf8');
             const settings = JSON.parse(content);
             if (settings.methods && typeof settings.methods === 'object') {
@@ -70,10 +72,6 @@ async function getInstalledMethodNames(targetDir) {
     }
     return methods;
 }
-/**
- * AIW gitignore section header marker
- */
-const AIW_GITIGNORE_HEADER = '# AIW Installation';
 /**
  * Check if a directory is empty.
  *
@@ -189,217 +187,6 @@ async function shouldDeleteIdeFolder(targetDir, ideFolder) {
 async function removeDirectory(dir) {
     await fs.rm(dir, { force: true, recursive: true });
 }
-/**
- * Update .gitignore to remove patterns for cleared folders.
- * Removes patterns from the AIW Installation section.
- *
- * @param targetDir - Directory containing .gitignore
- * @param foldersToRemove - Folder patterns to remove (without trailing slash)
- */
-async function updateGitignoreAfterClear(targetDir, foldersToRemove) {
-    const gitignorePath = join(targetDir, '.gitignore');
-    try {
-        const content = await fs.readFile(gitignorePath, 'utf8');
-        // Check if AIW Installation section exists
-        if (!content.includes(AIW_GITIGNORE_HEADER)) {
-            return;
-        }
-        // Split content into lines
-        const lines = content.split('\n');
-        const newLines = [];
-        let inAiwSection = false;
-        const aiwSectionLines = [];
-        // Parse lines and identify AIW section
-        for (const line of lines) {
-            if (line === AIW_GITIGNORE_HEADER) {
-                inAiwSection = true;
-                aiwSectionLines.push(line);
-                continue;
-            }
-            if (inAiwSection) {
-                // AIW section ends at empty line or another comment header
-                if (line === '' || (line.startsWith('#') && line !== AIW_GITIGNORE_HEADER)) {
-                    inAiwSection = false;
-                    // Process AIW section lines now
-                    const filteredAiwLines = filterAiwSection(aiwSectionLines, foldersToRemove);
-                    newLines.push(...filteredAiwLines, line);
-                }
-                else {
-                    aiwSectionLines.push(line);
-                }
-            }
-            else {
-                newLines.push(line);
-            }
-        }
-        // Handle case where AIW section is at end of file
-        if (inAiwSection) {
-            const filteredAiwLines = filterAiwSection(aiwSectionLines, foldersToRemove);
-            newLines.push(...filteredAiwLines);
-        }
-        // Clean up: remove AIW section entirely if only header remains
-        const finalContent = cleanupGitignoreContent(newLines.join('\n'));
-        await fs.writeFile(gitignorePath, finalContent, 'utf8');
-    }
-    catch {
-        // .gitignore doesn't exist or can't be read
-    }
-}
-/**
- * Filter AIW section lines to remove specified folders.
- *
- * @param aiwLines - Lines from AIW section (including header)
- * @param foldersToRemove - Folder names to remove
- * @returns Filtered lines
- */
-function filterAiwSection(aiwLines, foldersToRemove) {
-    const patternsToRemove = new Set(foldersToRemove.map((f) => `${f}/`));
-    return aiwLines.filter((line) => {
-        // Always keep the header
-        if (line === AIW_GITIGNORE_HEADER) {
-            return true;
-        }
-        // Remove matching patterns
-        return !patternsToRemove.has(line);
-    });
-}
-/**
- * Clean up gitignore content after filtering.
- * Removes AIW section if empty, cleans up extra newlines.
- *
- * @param content - Gitignore content
- * @returns Cleaned content
- */
-function cleanupGitignoreContent(content) {
-    const lines = content.split('\n');
-    const newLines = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Check if this is an AIW header with nothing following
-        if (line === AIW_GITIGNORE_HEADER) {
-            // Look ahead to see if there are any patterns
-            let hasPatterns = false;
-            const nextLine = lines[i + 1];
-            if (nextLine !== undefined && nextLine !== '' && !nextLine.startsWith('#')) {
-                hasPatterns = true;
-            }
-            if (!hasPatterns) {
-                // Skip the AIW header since it has no patterns
-                i++;
-                // Also skip any trailing empty lines that were before AIW section
-                while (newLines.length > 0 && newLines.at(-1) === '') {
-                    newLines.pop();
-                }
-                continue;
-            }
-        }
-        newLines.push(line);
-        i++;
-    }
-    // Ensure file ends with newline but not multiple
-    let result = newLines.join('\n');
-    result = result.replace(/\n+$/, '\n');
-    // Handle empty file case
-    if (result.trim() === '') {
-        return '';
-    }
-    return result;
-}
-/**
- * Update IDE settings file to remove method-specific entries.
- * Creates a backup before modifying.
- *
- * @param targetDir - Directory containing the IDE folder
- * @param ideFolder - IDE folder configuration (e.g., IDE_FOLDERS.claude)
- * @param ideFolder.root - Root folder name (e.g., '.claude')
- * @param ideFolder.settingsFile - Settings file name (e.g., 'settings.json')
- * @param methodsToRemove - Method names to remove from settings
- */
-async function updateIdeSettings(targetDir, ideFolder, methodsToRemove) {
-    const settingsPath = join(targetDir, ideFolder.root, ideFolder.settingsFile);
-    const result = { backedUp: false, updated: false };
-    try {
-        const content = await fs.readFile(settingsPath, 'utf8');
-        const settings = JSON.parse(content);
-        // Create backup before modifying
-        const backupPath = `${settingsPath}.backup`;
-        await fs.writeFile(backupPath, content, 'utf8');
-        result.backedUp = true;
-        // Remove method-specific entries from methods tracking object
-        let modified = false;
-        if (settings.methods && typeof settings.methods === 'object') {
-            for (const method of methodsToRemove) {
-                if (method in settings.methods) {
-                    delete settings.methods[method];
-                    modified = true;
-                }
-            }
-            // Remove methods object if empty
-            if (Object.keys(settings.methods).length === 0) {
-                delete settings.methods;
-                modified = true;
-            }
-        }
-        // Remove method-specific hooks from hooks array
-        if (settings.hooks && typeof settings.hooks === 'object') {
-            for (const hookType of Object.keys(settings.hooks)) {
-                const hookArray = settings.hooks[hookType];
-                if (Array.isArray(hookArray)) {
-                    const filtered = hookArray.filter((hook) => {
-                        // Check if hook command references any of the methods to remove
-                        if (hook.hooks && Array.isArray(hook.hooks)) {
-                            const filteredInner = hook.hooks.filter((innerHook) => {
-                                if (typeof innerHook.command === 'string') {
-                                    return !methodsToRemove.some((method) => innerHook.command?.toString().includes(`_${method}/`));
-                                }
-                                return true;
-                            });
-                            if (filteredInner.length !== hook.hooks.length) {
-                                hook.hooks = filteredInner;
-                                modified = true;
-                            }
-                            // Remove hook entry if all inner hooks were removed
-                            if (filteredInner.length === 0) {
-                                return false;
-                            }
-                        }
-                        return true;
-                    });
-                    if (filtered.length !== hookArray.length) {
-                        settings.hooks[hookType] = filtered;
-                        modified = true;
-                    }
-                    // Remove hook type if empty
-                    if (filtered.length === 0) {
-                        delete settings.hooks[hookType];
-                        modified = true;
-                    }
-                }
-            }
-            // Remove hooks object if empty
-            if (Object.keys(settings.hooks).length === 0) {
-                delete settings.hooks;
-                modified = true;
-            }
-        }
-        if (modified) {
-            // Write updated settings
-            const newContent = JSON.stringify(settings, null, 2) + '\n';
-            await fs.writeFile(settingsPath, newContent, 'utf8');
-            result.updated = true;
-        }
-        else {
-            // No changes needed, remove backup
-            await fs.unlink(backupPath);
-            result.backedUp = false;
-        }
-    }
-    catch {
-        // Settings file doesn't exist or can't be read
-    }
-    return result;
-}
 /**
  * Clear workflow folders, output folders, IDE method folders, and update configurations.
  */
@@ -591,6 +378,18 @@ export default class ClearCommand extends BaseCommand {
                 this.logInfo(`${IDE_FOLDERS.windsurf.root}/ folder will be removed (will be empty)`);
                 this.log('');
             }
+            // Compute gitignore changes for dry-run display
+            const gitignoreSimulation = await computeGitignoreRemovals(targetDir);
+            if (gitignoreSimulation.toRemove.length > 0 || gitignoreSimulation.toKeep.length > 0) {
+                this.logInfo('Gitignore changes:');
+                for (const { entry, reason } of gitignoreSimulation.toKeep) {
+                    this.log(`  keep ${entry}/ (${reason})`);
+                }
+                for (const entry of gitignoreSimulation.toRemove) {
+                    this.log(`  remove ${entry}/`);
+                }
+                this.log('');
+            }
             // Dry run - just show what would happen
             if (flags['dry-run']) {
                 this.logInfo('Dry run complete. No files or folders were deleted.');
@@ -654,29 +453,48 @@ export default class ClearCommand extends BaseCommand {
             catch {
                 // .aiwcli doesn't exist or can't be accessed
             }
-            // Update .gitignore to remove .aiwcli if the container was deleted
-            if (removedAiwcliContainer) {
-                await updateGitignoreAfterClear(targetDir, [AIWCLI_CONTAINER]);
-                this.logDebug('Updated .gitignore');
+            // Smart gitignore removal: compute what should be removed based on disk state
+            const { toRemove, toKeep } = await computeGitignoreRemovals(targetDir);
+            for (const { entry, reason } of toKeep) {
+                this.logDebug(`Keeping ${entry}/ in .gitignore (${reason})`);
+            }
+            if (toRemove.length > 0) {
+                await removeGitignoreEntries(targetDir, toRemove);
+                this.logDebug(`Removed from .gitignore: ${toRemove.join(', ')}`);
             }
-            // Prune stale gitignore entries (paths that no longer exist on disk)
+            // Prune stale gitignore entries as safety net
             const pruned = await pruneGitignoreStaleEntries(targetDir);
             if (pruned) {
                 this.logDebug('Pruned stale .gitignore entries');
             }
-            // Update IDE settings files to remove method-specific entries
+            // Reconstruct IDE settings from remaining templates
             let updatedClaudeSettings = false;
             let updatedWindsurfSettings = false;
             if (methodsToRemove.length > 0) {
-                const claudeResult = await updateIdeSettings(targetDir, IDE_FOLDERS.claude, methodsToRemove);
-                if (claudeResult.updated) {
-                    this.logDebug('Updated .claude/settings.json (backup created)');
-                    updatedClaudeSettings = true;
-                }
-                const windsurfResult = await updateIdeSettings(targetDir, IDE_FOLDERS.windsurf, methodsToRemove);
-                if (windsurfResult.updated) {
-                    this.logDebug('Updated .windsurf/hooks.json (backup created)');
-                    updatedWindsurfSettings = true;
+                // Remove method entries from settings files first
+                await this.removeMethodEntries(targetDir, methodsToRemove);
+                // Get remaining installed methods
+                const allMethods = await getInstalledMethodNames(targetDir);
+                // Filter out methods being removed (in case disk scan still finds them)
+                const remainingTemplates = [...allMethods].filter(m => !methodsToRemove.includes(m));
+                // Determine which IDEs need reconstruction
+                const ides = [];
+                if (await pathExists(join(targetDir, IDE_FOLDERS.claude.root))) {
+                    ides.push('claude');
+                }
+                if (await pathExists(join(targetDir, IDE_FOLDERS.windsurf.root))) {
+                    ides.push('windsurf');
+                }
+                if (ides.length > 0) {
+                    await reconstructIdeSettings(targetDir, remainingTemplates, ides);
+                    if (ides.includes('claude')) {
+                        this.logDebug('Reconstructed .claude/settings.json (backup created)');
+                        updatedClaudeSettings = true;
+                    }
+                    if (ides.includes('windsurf')) {
+                        this.logDebug('Reconstructed .windsurf/hooks.json (backup created)');
+                        updatedWindsurfSettings = true;
+                    }
                 }
             }
             // Check if IDE folders should be fully deleted (empty settings + empty subfolders)
@@ -733,7 +551,7 @@ export default class ClearCommand extends BaseCommand {
                 parts.push(`${IDE_FOLDERS.windsurf.root}/ folder`);
             }
             this.logSuccess(`Cleared: ${parts.join(', ')}.`);
-            if (removedAiwcliContainer || pruned) {
+            if (toRemove.length > 0 || pruned) {
                 this.logSuccess('Updated .gitignore.');
             }
             if (updatedClaudeSettings) {
@@ -755,151 +573,6 @@ export default class ClearCommand extends BaseCommand {
             });
         }
     }
-    /**
-     * Extract method names from workflow folder names (e.g., _gsd -> gsd).
-     *
-     * @param workflowFolders - Array of workflow folder paths
-     * @returns Array of method names
-     */
-    extractMethodNames(workflowFolders) {
-        const methods = [];
-        for (const folder of workflowFolders) {
-            const folderName = folder.split(/[/\\]/).pop() || '';
-            if (folderName.startsWith('_')) {
-                methods.push(folderName.slice(1));
-            }
-        }
-        return methods;
-    }
-    /**
-     * 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
-     */
-    async findIdeMethodFolders(targetDir, template) {
-        // Build method set: from --template flag, or from installed methods
-        const methodNames = template ? new Set([template]) : await getInstalledMethodNames(targetDir);
-        if (methodNames.size === 0) {
-            return [];
-        }
-        // For each IDE root, scan all subdirectories for children matching method names
-        const ideRoots = Object.values(IDE_FOLDERS).map((ide) => join(targetDir, ide.root));
-        const ideResults = await Promise.all(ideRoots.map(async (ideRoot) => {
-            // Get all subdirectories of IDE root (e.g., .claude/commands/, .claude/skills/)
-            try {
-                const topEntries = await fs.readdir(ideRoot, { withFileTypes: true });
-                const subdirs = topEntries.filter((e) => e.isDirectory());
-                // For each subdirectory, check for method-named children
-                const subResults = await Promise.all(subdirs.map(async (subdir) => {
-                    const subdirPath = join(ideRoot, subdir.name);
-                    try {
-                        const entries = await fs.readdir(subdirPath, { withFileTypes: true });
-                        return entries
-                            .filter((entry) => entry.isDirectory() && methodNames.has(entry.name))
-                            .map((entry) => join(subdirPath, entry.name));
-                    }
-                    catch {
-                        return [];
-                    }
-                }));
-                return subResults.flat();
-            }
-            catch {
-                return [];
-            }
-        }));
-        return ideResults.flat();
-    }
-    /**
-     * Find all output folders in the target directory.
-     * Looks for .aiwcli/_output/{method}/ structure.
-     *
-     * @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
-     */
-    async findOutputFolders(targetDir, template) {
-        const containerDir = join(targetDir, AIWCLI_CONTAINER);
-        const outputDir = join(containerDir, OUTPUT_FOLDER_NAME);
-        // Check if _output folder exists
-        try {
-            const stat = await fs.stat(outputDir);
-            if (!stat.isDirectory()) {
-                return [];
-            }
-        }
-        catch {
-            // _output folder doesn't exist
-            return [];
-        }
-        // If template specified, only look for that specific method folder
-        if (template) {
-            const methodPath = join(outputDir, template);
-            try {
-                const stat = await fs.stat(methodPath);
-                if (stat.isDirectory()) {
-                    return [methodPath];
-                }
-            }
-            catch {
-                // Method folder doesn't exist
-            }
-            return [];
-        }
-        // No template filter - find all method folders within _output
-        const foundFolders = [];
-        try {
-            const entries = await fs.readdir(outputDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    foundFolders.push(join(outputDir, entry.name));
-                }
-            }
-        }
-        catch {
-            // Directory can't be read - return empty
-        }
-        return foundFolders;
-    }
-    /**
-     * Find all workflow 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 workflow folder paths
-     */
-    async findWorkflowFolders(targetDir, template) {
-        const foundFolders = [];
-        const containerDir = join(targetDir, AIWCLI_CONTAINER);
-        try {
-            const entries = await fs.readdir(containerDir, { withFileTypes: true });
-            for (const entry of entries) {
-                // Look for directories starting with underscore (workflow folders)
-                if (entry.isDirectory() && entry.name.startsWith('_') && entry.name !== OUTPUT_FOLDER_NAME) {
-                    // If template specified, only include matching folder
-                    if (template) {
-                        if (entry.name === `_${template}`) {
-                            foundFolders.push(join(containerDir, entry.name));
-                        }
-                    }
-                    else {
-                        foundFolders.push(join(containerDir, entry.name));
-                    }
-                }
-            }
-        }
-        catch {
-            // Directory can't be read - return empty
-        }
-        return foundFolders;
-    }
     /**
      * Clean runtime output artifacts from _output/ at project root.
      * Handles temp files, cache files, log rotation, and archive cleanup.
@@ -907,6 +580,7 @@ export default class ClearCommand extends BaseCommand {
      * @param targetDir - Project root directory
      * @param flags - Command flags (dry-run, force)
      */
+    // eslint-disable-next-line complexity
     async cleanRuntimeOutput(targetDir, flags) {
         const outputDir = join(targetDir, '_output');
         if (!(await pathExists(outputDir))) {
@@ -934,7 +608,7 @@ export default class ClearCommand extends BaseCommand {
                 // Log rotation: hook-log.jsonl > 1MB
                 if (entry.isFile() && entry.name === 'hook-log.jsonl') {
                     try {
-                        const stat = await fs.stat(entryPath);
+                        const stat = await fs.stat(entryPath); // eslint-disable-line no-await-in-loop
                         if (stat.size > 1_048_576) {
                             logAction = { path: entryPath, sizeBytes: stat.size };
                         }
@@ -948,7 +622,7 @@ export default class ClearCommand extends BaseCommand {
                 if (entry.isDirectory() && entry.name === 'contexts') {
                     const archivePath = join(entryPath, '_archive');
                     try {
-                        const archiveEntries = await fs.readdir(archivePath);
+                        const archiveEntries = await fs.readdir(archivePath); // eslint-disable-line no-await-in-loop
                         if (archiveEntries.length > 0) {
                             archiveDir = archivePath;
                             archiveCount = archiveEntries.length;
@@ -1008,7 +682,7 @@ export default class ClearCommand extends BaseCommand {
         let deletedCount = 0;
         for (const item of toDelete) {
             try {
-                await fs.unlink(item.path);
+                await fs.unlink(item.path); // eslint-disable-line no-await-in-loop
                 deletedCount++;
             }
             catch (error) {
@@ -1024,7 +698,7 @@ export default class ClearCommand extends BaseCommand {
                 const truncated = content.slice(-524_288);
                 // Find the first complete line
                 const firstNewline = truncated.indexOf('\n');
-                const cleaned = firstNewline >= 0 ? truncated.slice(firstNewline + 1) : truncated;
+                const cleaned = firstNewline === -1 ? truncated : truncated.slice(firstNewline + 1);
                 await fs.writeFile(logAction.path, cleaned, 'utf8');
                 this.logDebug('Rotated hook-log.jsonl');
             }
@@ -1072,4 +746,178 @@ export default class ClearCommand extends BaseCommand {
             this.logInfo('No changes made.');
         }
     }
+    /**
+     * Extract method names from workflow folder names (e.g., _gsd -> gsd).
+     *
+     * @param workflowFolders - Array of workflow folder paths
+     * @returns Array of method names
+     */
+    extractMethodNames(workflowFolders) {
+        const methods = [];
+        for (const folder of workflowFolders) {
+            const folderName = folder.split(/[/\\]/).pop() || '';
+            if (folderName.startsWith('_')) {
+                methods.push(folderName.slice(1));
+            }
+        }
+        return methods;
+    }
+    /**
+     * 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
+     */
+    async findIdeMethodFolders(targetDir, template) {
+        // Build method set: from --template flag, or from installed methods
+        const methodNames = template ? new Set([template]) : await getInstalledMethodNames(targetDir);
+        if (methodNames.size === 0) {
+            return [];
+        }
+        // For each IDE root, scan all subdirectories for children matching method names
+        const ideRoots = Object.values(IDE_FOLDERS).map((ide) => join(targetDir, ide.root));
+        const ideResults = await Promise.all(ideRoots.map(async (ideRoot) => {
+            // Get all subdirectories of IDE root (e.g., .claude/commands/, .claude/skills/)
+            try {
+                const topEntries = await fs.readdir(ideRoot, { withFileTypes: true });
+                const subdirs = topEntries.filter((e) => e.isDirectory());
+                // For each subdirectory, check for method-named children
+                const subResults = await Promise.all(subdirs.map(async (subdir) => {
+                    const subdirPath = join(ideRoot, subdir.name);
+                    try {
+                        const entries = await fs.readdir(subdirPath, { withFileTypes: true });
+                        return entries
+                            .filter((entry) => entry.isDirectory() && methodNames.has(entry.name))
+                            .map((entry) => join(subdirPath, entry.name));
+                    }
+                    catch {
+                        return [];
+                    }
+                }));
+                return subResults.flat();
+            }
+            catch {
+                return [];
+            }
+        }));
+        return ideResults.flat();
+    }
+    /**
+     * Find all output folders in the target directory.
+     * Looks for .aiwcli/_output/{method}/ structure.
+     *
+     * @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
+     */
+    async findOutputFolders(targetDir, template) {
+        const containerDir = join(targetDir, AIWCLI_CONTAINER);
+        const outputDir = join(containerDir, OUTPUT_FOLDER_NAME);
+        // Check if _output folder exists
+        try {
+            const stat = await fs.stat(outputDir);
+            if (!stat.isDirectory()) {
+                return [];
+            }
+        }
+        catch {
+            // _output folder doesn't exist
+            return [];
+        }
+        // If template specified, only look for that specific method folder
+        if (template) {
+            const methodPath = join(outputDir, template);
+            try {
+                const stat = await fs.stat(methodPath);
+                if (stat.isDirectory()) {
+                    return [methodPath];
+                }
+            }
+            catch {
+                // Method folder doesn't exist
+            }
+            return [];
+        }
+        // No template filter - find all method folders within _output
+        const foundFolders = [];
+        try {
+            const entries = await fs.readdir(outputDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    foundFolders.push(join(outputDir, entry.name));
+                }
+            }
+        }
+        catch {
+            // Directory can't be read - return empty
+        }
+        return foundFolders;
+    }
+    /**
+     * Find all workflow 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 workflow folder paths
+     */
+    async findWorkflowFolders(targetDir, template) {
+        const foundFolders = [];
+        const containerDir = join(targetDir, AIWCLI_CONTAINER);
+        try {
+            const entries = await fs.readdir(containerDir, { withFileTypes: true });
+            for (const entry of entries) {
+                // Look for directories starting with underscore (workflow folders)
+                if (entry.isDirectory() && entry.name.startsWith('_') && entry.name !== OUTPUT_FOLDER_NAME) {
+                    // If template specified, only include matching folder
+                    if (template) {
+                        if (entry.name === `_${template}`) {
+                            foundFolders.push(join(containerDir, entry.name));
+                        }
+                    }
+                    else {
+                        foundFolders.push(join(containerDir, entry.name));
+                    }
+                }
+            }
+        }
+        catch {
+            // Directory can't be read - return empty
+        }
+        return foundFolders;
+    }
+    /**
+     * Remove method entries from IDE settings files (methods tracking only).
+     * Settings reconstruction handles hooks/permissions; this only strips the methods object.
+     */
+    async removeMethodEntries(targetDir, methodsToRemove) {
+        const ops = Object.values(IDE_FOLDERS).map(async (ide) => {
+            const settingsPath = join(targetDir, ide.root, ide.settingsFile);
+            try {
+                const content = await fs.readFile(settingsPath, 'utf8');
+                const settings = JSON.parse(content);
+                if (settings.methods && typeof settings.methods === 'object') {
+                    for (const method of methodsToRemove) {
+                        if (method in settings.methods) {
+                            delete settings.methods[method];
+                        }
+                    }
+                    if (Object.keys(settings.methods).length === 0) {
+                        delete settings.methods;
+                    }
+                    // Write back with methods removed (backup created by reconstructor)
+                    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+                }
+            }
+            catch {
+                // Settings file doesn't exist or can't be read
+            }
+        });
+        await Promise.all(ops);
+    }
 }