aiwcli 0.10.2 → 0.10.3

package/dist/commands/clear.d.ts

@@ -15,6 +15,14 @@ export default class ClearCommand extends BaseCommand {
         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)
+     */
+    private cleanRuntimeOutput;
     /**
      * Extract method names from workflow folder names (e.g., _gsd -> gsd).
      *
@@ -53,11 +61,8 @@ export default class ClearCommand extends BaseCommand {
      */
     private findWorkflowFolders;
     /**
-     * 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)
+     * Remove method entries from IDE settings files (methods tracking only).
+     * Settings reconstruction handles hooks/permissions; this only strips the methods object.
      */
-    private cleanRuntimeOutput;
+    private removeMethodEntries;
 }

package/dist/commands/clear.js

@@ -5,6 +5,7 @@ import { Flags } from '@oclif/core';
 import BaseCommand from '../lib/base-command.js';
 import { pruneGitignoreStaleEntries } 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
@@ -306,100 +307,6 @@ function cleanupGitignoreContent(content) {
     }
     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.
  */
@@ -664,19 +571,34 @@ export default class ClearCommand extends BaseCommand {
             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;
+                // 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');
                 }
-                const windsurfResult = await updateIdeSettings(targetDir, IDE_FOLDERS.windsurf, methodsToRemove);
-                if (windsurfResult.updated) {
-                    this.logDebug('Updated .windsurf/hooks.json (backup created)');
-                    updatedWindsurfSettings = true;
+                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)
@@ -755,151 +677,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.
@@ -1024,7 +801,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 +849,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);
+    }
 }

package/dist/commands/init/index.d.ts

@@ -29,28 +29,12 @@ export default class Init extends BaseCommand {
      * @returns Template description
      */
     private getTemplateDescription;
-    /**
-     * Merge settings from multiple method templates into project settings.
-     * Processes methods in order, allowing later methods to override earlier ones.
-     *
-     * @param targetDir - Project directory
-     * @param methods - Array of method names to merge (e.g., ['_shared', 'cc-native'])
-     * @param ides - IDEs being configured (for IDE-specific merging)
-     */
-    private mergeMethodsSettings;
-    /**
-     * Merge Windsurf template hooks into project hooks
-     *
-     * @param targetDir - Project directory
-     * @param templatePath - Template source path
-     */
-    private mergeWindsurfTemplateHooks;
     /**
      * Perform post-installation actions.
      *
      * Handles:
      * - Method tracking in settings.json
-     * - Settings/hooks merging for all methods
+     * - Settings reconstruction from all active templates
      * - .gitignore updates
      *
      * @param config - Post-install configuration