aiwcli 0.10.2 → 0.10.3

package/dist/commands/init/index.js

@@ -4,16 +4,14 @@ import { fileURLToPath } from 'node:url';
 import { checkbox, confirm, input, select } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../lib/base-command.js';
-import { detectUsername } from '../../lib/user-utils.js';
 import { updateGitignore } from '../../lib/gitignore-manager.js';
-import { mergeClaudeSettings } from '../../lib/hooks-merger.js';
 import { IdePathResolver } from '../../lib/ide-path-resolver.js';
 import { pathExists } from '../../lib/paths.js';
 import { getTargetSettingsFile, readClaudeSettings, writeClaudeSettings } from '../../lib/settings-hierarchy.js';
 import { checkTemplateStatus, installTemplate, shouldExclude } from '../../lib/template-installer.js';
 import { getAvailableTemplates, getTemplatePath } from '../../lib/template-resolver.js';
-import { getTargetHooksFile, readWindsurfHooks, writeWindsurfHooks } from '../../lib/windsurf-hooks-hierarchy.js';
-import { mergeWindsurfHooks } from '../../lib/windsurf-hooks-merger.js';
+import { reconstructIdeSettings } from '../../lib/template-settings-reconstructor.js';
+import { detectUsername } from '../../lib/user-utils.js';
 import { EXIT_CODES } from '../../types/exit-codes.js';
 /**
  * Available IDEs for configuration
@@ -93,7 +91,10 @@ export default class Init extends BaseCommand {
                 await fs.mkdir(containerDir, { recursive: true });
                 const sharedDestPath = resolver.getSharedFolder();
                 const sharedExists = await pathExists(sharedDestPath);
-                if (!sharedExists) {
+                if (sharedExists) {
+                    this.logInfo('✓ _shared folder already exists - skipping');
+                }
+                else {
                     const currentFilePath = fileURLToPath(import.meta.url);
                     const currentDir = dirname(currentFilePath);
                     const templatesRoot = join(dirname(dirname(currentDir)), 'templates');
@@ -106,11 +107,8 @@ export default class Init extends BaseCommand {
                     await this.copyDirectory(sharedSrcPath, sharedDestPath, true);
                     this.logSuccess('✓ Installed _shared folder');
                 }
-                else {
-                    this.logInfo('✓ _shared folder already exists - skipping');
-                }
-                // Merge settings from _shared template
-                await this.mergeMethodsSettings(targetDir, ['_shared'], ['claude']);
+                // Reconstruct settings from _shared template
+                await reconstructIdeSettings(targetDir, [], ['claude']);
                 // Update .gitignore if git repository exists
                 if (hasGit) {
                     await updateGitignore(targetDir, ['.aiwcli']);
@@ -169,7 +167,7 @@ export default class Init extends BaseCommand {
                 // Still update gitignore and merge hooks if needed
             }
             this.log('');
-            // Install template with selective installation (skip existing items)
+            // Install template (always overwrites method-owned content)
             const result = await installTemplate({
                 templateName: method,
                 targetDir,
@@ -177,7 +175,7 @@ export default class Init extends BaseCommand {
                 username,
                 projectName,
                 templatePath,
-            }, true);
+            });
             // Collect all folders that need gitignore entries
             // The .aiwcli/ container holds all template infrastructure and runtime data
             const foldersForGitignore = ['.aiwcli'];
@@ -185,12 +183,6 @@ export default class Init extends BaseCommand {
             if (result.installedFolders.length > 0) {
                 this.logSuccess(`✓ Installed: ${result.installedFolders.join(', ')}`);
             }
-            if (result.mergedFolders.length > 0) {
-                this.logSuccess(`✓ Merged content into: ${result.mergedFolders.join(', ')} (${result.mergedFileCount} files)`);
-            }
-            if (result.skippedFolders.length > 0) {
-                this.logInfo(`✓ Skipped (already exist): ${result.skippedFolders.join(', ')}`);
-            }
             // Perform post-installation actions (settings tracking, hook merging, gitignore updates)
             await this.performPostInstallActions({
                 targetDir,
@@ -271,94 +263,12 @@ export default class Init extends BaseCommand {
         };
         return descriptions[template] || 'Custom template';
     }
-    /**
-     * 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)
-     */
-    async mergeMethodsSettings(targetDir, methods, ides) {
-        const targetSettingsPath = getTargetSettingsFile(targetDir);
-        let projectSettings = (await readClaudeSettings(targetSettingsPath)) || {};
-        for (const method of methods) {
-            try {
-                // Get template path for this method
-                let templatePath;
-                if (method === '_shared') {
-                    // Special case: _shared is at templates/_shared
-                    const currentFilePath = fileURLToPath(import.meta.url);
-                    const currentDir = dirname(currentFilePath);
-                    const templatesRoot = join(dirname(dirname(currentDir)), 'templates');
-                    templatePath = join(templatesRoot, '_shared');
-                }
-                else {
-                    // Named method templates
-                    templatePath = await getTemplatePath(method);
-                }
-                // Merge Claude settings if claude IDE is selected
-                if (ides.includes('claude')) {
-                    const templateSettingsPath = join(templatePath, '.claude', 'settings.json');
-                    const templateSettings = await readClaudeSettings(templateSettingsPath);
-                    if (templateSettings) {
-                        projectSettings = mergeClaudeSettings(projectSettings, templateSettings);
-                        this.logSuccess(`✓ Merged ${method} settings into .claude/settings.json`);
-                    }
-                }
-                // Merge Windsurf hooks if windsurf IDE is selected
-                if (ides.includes('windsurf')) {
-                    await this.mergeWindsurfTemplateHooks(targetDir, templatePath);
-                }
-            }
-            catch (error) {
-                const err = error;
-                this.warn(`Failed to merge ${method} settings: ${err.message}`);
-            }
-        }
-        // Write merged Claude settings
-        if (ides.includes('claude')) {
-            await writeClaudeSettings(targetSettingsPath, projectSettings);
-        }
-    }
-    /**
-     * Merge Windsurf template hooks into project hooks
-     *
-     * @param targetDir - Project directory
-     * @param templatePath - Template source path
-     */
-    async mergeWindsurfTemplateHooks(targetDir, templatePath) {
-        try {
-            // Read template hooks
-            const templateHooksPath = join(templatePath, '.windsurf', 'hooks.json');
-            const templateHooks = await readWindsurfHooks(templateHooksPath);
-            // If template has no hooks, nothing to merge
-            if (!templateHooks || !templateHooks.hooks || Object.keys(templateHooks.hooks).length === 0) {
-                this.logInfo('No Windsurf hooks in template to merge');
-                return;
-            }
-            // Get target hooks file path
-            const targetHooksPath = getTargetHooksFile(targetDir);
-            // Read existing project hooks
-            const existingHooks = await readWindsurfHooks(targetHooksPath);
-            // Merge hooks
-            const mergedHooks = mergeWindsurfHooks(existingHooks, templateHooks);
-            // Write merged hooks
-            await writeWindsurfHooks(targetHooksPath, mergedHooks);
-            this.logSuccess('✓ Windsurf template hooks merged into project hooks');
-        }
-        catch (error) {
-            const err = error;
-            this.warn(`Failed to merge Windsurf template hooks: ${err.message}`);
-            // Don't fail the entire installation if hook merging fails
-        }
-    }
     /**
      * 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
@@ -370,10 +280,15 @@ export default class Init extends BaseCommand {
      */
     async performPostInstallActions(config) {
         const { targetDir, method, ides, hasGit, foldersForGitignore } = config;
-        // Track method installation in settings.json
+        // Track method installation in settings.json first (so reconstructor can read methods list)
         await this.trackMethodInstallation(targetDir, method, ides);
-        // Merge settings from _shared and method templates
-        await this.mergeMethodsSettings(targetDir, ['_shared', method], ides);
+        // Read installed methods to build active templates list
+        const settingsPath = getTargetSettingsFile(targetDir);
+        const settings = await readClaudeSettings(settingsPath);
+        const activeTemplates = settings?.methods ? Object.keys(settings.methods) : [method];
+        // Reconstruct IDE settings from all active templates
+        await reconstructIdeSettings(targetDir, activeTemplates, ides);
+        this.logSuccess('✓ Reconstructed IDE settings from active templates');
         // Update .gitignore if git repository exists
         if (hasGit) {
             await updateGitignore(targetDir, foldersForGitignore);

package/dist/lib/template-installer.d.ts

@@ -45,14 +45,8 @@ export interface TemplateInstallationStatus {
 export interface InstallationResult {
     /** List of folder names that were installed (for gitignore) */
     installedFolders: string[];
-    /** Number of files that were merged into existing folders */
-    mergedFileCount: number;
-    /** List of folder names that had content merged */
-    mergedFolders: string[];
     /** Whether shared settings were merged into IDE settings */
     sharedSettingsMerged: boolean;
-    /** List of folder names that were skipped (already exist) */
-    skippedFolders: string[];
     /** Absolute path to the template that was installed */
     templatePath: string;
 }
@@ -87,15 +81,16 @@ export declare function shouldExclude(name: string): boolean;
 export declare function copyDir(src: string, dest: string, excludeIdeFolders?: boolean): Promise<void>;
 /**
  * Install template with IDE-specific folder selection.
- * Supports selective installation - only installs items that don't already exist.
  *
  * Template structure:
- * - Non-dot folders (e.g., _bmad/, GSR/) are installed if not already present
- * - Dot folders (e.g., .claude/, .windsurf/) are installed only if matching IDE flag and not already present
+ * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
+ * - _shared/ → .aiwcli/_shared/ (always overwritten)
+ * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
+ *
+ * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().
  *
  * @param config - Installation configuration
- * @param skipExisting - If true, skip items that already exist (default: true for regeneration support)
- * @returns Installation result with list of installed and skipped folders
+ * @returns Installation result with list of installed folders
  * @throws Error if template doesn't exist or requested IDE folder not found
  */
-export declare function installTemplate(config: TemplateInstallConfig, skipExisting?: boolean): Promise<InstallationResult>;
+export declare function installTemplate(config: TemplateInstallConfig): Promise<InstallationResult>;

package/dist/lib/template-installer.js

@@ -2,98 +2,6 @@ import { promises as fs } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { IdePathResolver } from './ide-path-resolver.js';
 import { pathExists } from './paths.js';
-import { mergeTemplateContent } from './template-merger.js';
-/**
- * Deep merge two settings objects, combining hook arrays.
- * Used to merge _shared/settings.json into .claude/settings.json
- */
-function deepMergeSettings(target, source) {
-    const result = { ...target };
-    for (const key of Object.keys(source)) {
-        // Skip comment fields
-        if (key.startsWith('$') || key.startsWith('_')) {
-            continue;
-        }
-        const sourceValue = source[key];
-        const targetValue = result[key];
-        if (key === 'hooks' && typeof sourceValue === 'object' && sourceValue !== null) {
-            // Special handling for hooks - merge by event type
-            result[key] = mergeHooks(targetValue || {}, sourceValue);
-        }
-        else if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
-            // Concatenate arrays
-            result[key] = [...targetValue, ...sourceValue];
-        }
-        else if (typeof sourceValue === 'object' && sourceValue !== null && typeof targetValue === 'object' && targetValue !== null) {
-            // Recursively merge objects
-            result[key] = deepMergeSettings(targetValue, sourceValue);
-        }
-        else {
-            // Override with source value
-            result[key] = sourceValue;
-        }
-    }
-    return result;
-}
-/**
- * Merge hook configurations, combining arrays for each event type.
- */
-function mergeHooks(target, source) {
-    const result = { ...target };
-    for (const eventType of Object.keys(source)) {
-        const targetHooks = result[eventType];
-        const sourceHooks = source[eventType];
-        if (targetHooks && sourceHooks) {
-            // Append source hooks to existing event type
-            result[eventType] = [...targetHooks, ...sourceHooks];
-        }
-        else if (sourceHooks) {
-            // New event type
-            result[eventType] = sourceHooks;
-        }
-    }
-    return result;
-}
-/**
- * Merge settings from a source settings.json file into the IDE settings file.
- * Reads from the provided source path and merges into .claude/settings.json at project root.
- *
- * @param targetDir - Project root directory
- * @param sourceSettingsPath - Absolute path to source settings.json file
- * @returns true if merge successful, false otherwise
- */
-async function mergeSharedSettingsFromSource(targetDir, sourceSettingsPath) {
-    const resolver = new IdePathResolver(targetDir);
-    const ideSettingsPath = resolver.getClaudeSettings();
-    // Check if source settings exists
-    if (!(await pathExists(sourceSettingsPath))) {
-        return false;
-    }
-    try {
-        // Read source settings
-        const sourceContent = await fs.readFile(sourceSettingsPath, 'utf8');
-        const sourceSettings = JSON.parse(sourceContent);
-        // Read IDE settings (create empty object if doesn't exist)
-        let ideSettings = {};
-        if (await pathExists(ideSettingsPath)) {
-            const ideContent = await fs.readFile(ideSettingsPath, 'utf8');
-            ideSettings = JSON.parse(ideContent);
-        }
-        else {
-            // Create .claude directory if it doesn't exist
-            await fs.mkdir(dirname(ideSettingsPath), { recursive: true });
-        }
-        // Merge source settings into IDE settings
-        const mergedSettings = deepMergeSettings(ideSettings, sourceSettings);
-        // Write merged settings back
-        await fs.writeFile(ideSettingsPath, JSON.stringify(mergedSettings, null, 4) + '\n', 'utf8');
-        return true;
-    }
-    catch {
-        // Silently fail on parse/write errors
-        return false;
-    }
-}
 /**
  * Check template installation status for a method.
  * Returns which items exist and which are missing.
@@ -186,32 +94,6 @@ export function shouldExclude(name) {
         return pattern.test(name);
     });
 }
-/**
- * Merge source directory into destination, skipping existing files.
- * Unlike copyDir, this preserves existing files in destination.
- *
- * @param src - Source directory path
- * @param dest - Destination directory path
- */
-async function mergeDirectory(src, dest) {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-        if (shouldExclude(entry.name))
-            continue;
-        const srcPath = join(src, entry.name);
-        const destPath = join(dest, entry.name);
-        if (entry.isDirectory()) {
-            await mergeDirectory(srcPath, destPath);
-        }
-        else {
-            // Skip if file already exists
-            if (!(await pathExists(destPath))) {
-                await fs.copyFile(srcPath, destPath);
-            }
-        }
-    }
-}
 /**
  * Copy directory recursively with proper error handling.
  * Excludes test files, cache directories, and output folders.
@@ -249,20 +131,45 @@ export async function copyDir(src, dest, excludeIdeFolders = false) {
     });
     await Promise.all(operations);
 }
+/**
+ * Merge source directory into destination, skipping existing files.
+ * Unlike copyDir, this preserves existing files in destination.
+ *
+ * @param src - Source directory path
+ * @param dest - Destination directory path
+ */
+async function mergeDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    const ops = entries
+        .filter((entry) => !shouldExclude(entry.name))
+        .map(async (entry) => {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await mergeDirectory(srcPath, destPath);
+        }
+        else if (!(await pathExists(destPath))) {
+            await fs.copyFile(srcPath, destPath);
+        }
+    });
+    await Promise.all(ops);
+}
 /**
  * Install template with IDE-specific folder selection.
- * Supports selective installation - only installs items that don't already exist.
  *
  * Template structure:
- * - Non-dot folders (e.g., _bmad/, GSR/) are installed if not already present
- * - Dot folders (e.g., .claude/, .windsurf/) are installed only if matching IDE flag and not already present
+ * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
+ * - _shared/ → .aiwcli/_shared/ (always overwritten)
+ * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
+ *
+ * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().
  *
  * @param config - Installation configuration
- * @param skipExisting - If true, skip items that already exist (default: true for regeneration support)
- * @returns Installation result with list of installed and skipped folders
+ * @returns Installation result with list of installed folders
  * @throws Error if template doesn't exist or requested IDE folder not found
  */
-export async function installTemplate(config, skipExisting = true) {
+export async function installTemplate(config) {
     const { templateName, targetDir, ides, templatePath } = config;
     // Verify template exists
     try {
@@ -295,108 +202,77 @@ export async function installTemplate(config, skipExisting = true) {
             `Available: ${availableIdes.join(', ')}`);
     }
     const installedFolders = [];
-    const skippedFolders = [];
-    const mergedFolders = [];
-    let mergedFileCount = 0;
     // Create .aiwcli container folder for method-specific files
     const resolver = new IdePathResolver(targetDir);
     const containerDir = resolver.getAiwcliContainer();
     await fs.mkdir(containerDir, { recursive: true });
-    // Install non-dot folders into .aiwcli/ container (skip if already exist and skipExisting is true)
+    // Install non-dot folders into .aiwcli/ container (always overwrite)
     const nonDotInstalls = nonDotFolders.map(async (folder) => {
         const srcPath = join(templatePath, folder);
-        // Destination is inside .aiwcli/ container
         const destPath = join(containerDir, folder);
-        if (skipExisting && (await pathExists(destPath))) {
-            return { folder, skipped: true };
-        }
         await copyDir(srcPath, destPath);
-        return { folder, skipped: false };
+        return folder;
     });
     const nonDotResults = await Promise.all(nonDotInstalls);
-    for (const result of nonDotResults) {
-        if (result.skipped) {
-            skippedFolders.push(result.folder);
-        }
-        else {
-            installedFolders.push(result.folder);
-        }
-    }
+    installedFolders.push(...nonDotResults);
     // Install root-level _shared directory (shared across all templates)
-    // This is at templates/_shared, not inside the specific template directory
     // Exclude IDE config folders (.claude, .windsurf) - they are used for settings merging only
     const templatesRoot = dirname(templatePath);
     const rootSharedSrc = join(templatesRoot, '_shared');
     const rootSharedDest = join(containerDir, '_shared');
     if (await pathExists(rootSharedSrc)) {
-        if (skipExisting && (await pathExists(rootSharedDest))) {
-            skippedFolders.push('_shared');
-        }
-        else {
-            await copyDir(rootSharedSrc, rootSharedDest, true); // excludeIdeFolders = true
-            installedFolders.push('_shared');
-        }
-        // Merge shared IDE folders (commands, workflows) into project IDE folders
-        // This handles _shared/.claude/, _shared/.windsurf/, etc.
+        await copyDir(rootSharedSrc, rootSharedDest, true); // excludeIdeFolders = true
+        installedFolders.push('_shared');
+        // Copy shared IDE content (e.g., _shared/.claude/commands/handoff.md)
+        // These are non-method-owned files that live in IDE folders
         const sharedIdeInstalls = ides.map(async (ide) => {
             const sharedIdeFolder = join(rootSharedSrc, `.${ide}`);
             if (await pathExists(sharedIdeFolder)) {
                 const destIdeFolder = resolver.getIdeDir(ide);
                 await fs.mkdir(destIdeFolder, { recursive: true });
-                // Recursively copy, but skip files that already exist
+                // Merge shared IDE content, skipping files that already exist
                 await mergeDirectory(sharedIdeFolder, destIdeFolder);
             }
         });
         await Promise.all(sharedIdeInstalls);
     }
-    // Install matching IDE folders
-    // If folder exists, merge content recursively by looking for method name folders
+    // Install method-owned IDE content (decomposed approach)
+    // Instead of copying entire .claude/ from template, only copy method-namespaced subdirectories
     const ideInstalls = ides.map(async (ide) => {
         const folderName = dotFolders.get(ide);
-        if (folderName) {
-            const srcPath = join(templatePath, folderName);
-            const destPath = resolver.getIdeDir(ide);
-            if (await pathExists(destPath)) {
-                if (skipExisting) {
-                    // Folder exists - merge template content by finding method-named folders
-                    const mergeResult = await mergeTemplateContent(srcPath, destPath, templateName);
-                    return {
-                        folder: folderName,
-                        skipped: false,
-                        merged: true,
-                        mergedFiles: mergeResult.copiedFiles.length,
-                    };
-                }
-                // skipExisting is false, so overwrite
-                await copyDir(srcPath, destPath);
-                return { folder: folderName, skipped: false, merged: false, mergedFiles: 0 };
+        if (!folderName)
+            return null;
+        const srcIdePath = join(templatePath, folderName);
+        const destIdePath = resolver.getIdeDir(ide);
+        await fs.mkdir(destIdePath, { recursive: true });
+        // Scan the template IDE folder for subdirectories and copy method-owned content
+        const ideEntries = await fs.readdir(srcIdePath, { withFileTypes: true });
+        const subdirOps = ideEntries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            const subdirSrc = join(srcIdePath, entry.name);
+            const subdirDest = join(destIdePath, entry.name);
+            // Check for method-namespaced child within this subdirectory
+            const methodChildSrc = join(subdirSrc, templateName);
+            if (await pathExists(methodChildSrc)) {
+                // Copy only the method-namespaced subdirectory (overwrite)
+                const methodChildDest = join(subdirDest, templateName);
+                await copyDir(methodChildSrc, methodChildDest);
             }
-            await copyDir(srcPath, destPath);
-            return { folder: folderName, skipped: false, merged: false, mergedFiles: 0 };
-        }
-        return null;
+            else {
+                // No method-namespaced child — copy the entire subdirectory, merging with existing
+                await mergeDirectory(subdirSrc, subdirDest);
+            }
+        });
+        await Promise.all(subdirOps);
+        return folderName;
     });
     const ideResults = (await Promise.all(ideInstalls)).filter((result) => result !== null);
-    for (const result of ideResults) {
-        if (result.merged) {
-            mergedFolders.push(result.folder);
-            mergedFileCount += result.mergedFiles;
-        }
-        else if (result.skipped) {
-            skippedFolders.push(result.folder);
-        }
-        else {
-            installedFolders.push(result.folder);
-        }
-    }
-    // Settings merging is now handled by the caller via mergeMethodsSettings()
-    // This allows unified merging of _shared + method-specific settings
+    installedFolders.push(...ideResults);
+    // Settings reconstruction is handled by the caller via reconstructIdeSettings()
     return {
         installedFolders,
-        skippedFolders,
-        mergedFolders,
-        mergedFileCount,
-        sharedSettingsMerged: false, // Deprecated, kept for backwards compatibility
+        sharedSettingsMerged: false,
         templatePath,
     };
 }

package/dist/lib/template-settings-reconstructor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Unified reconstruction of shared IDE settings files.
+ *
+ * Both `aiw init` and `aiw clear` use the same operation: reconstruct shared
+ * settings from the union of all active templates. Install adds a template to
+ * the list; clear removes one. The reconstruction logic is identical.
+ *
+ * Template files fall into two categories:
+ * 1. **Method-owned** — lives in method-namespaced paths (e.g., `.claude/commands/cc-native/`),
+ *    owned exclusively by one template. Handled by copy/delete, not by this module.
+ * 2. **Shared** — lives in common locations (e.g., `settings.json`), multiple templates
+ *    contribute. Handled by this module via reconstruction from source.
+ *
+ * @module lib/template-settings-reconstructor
+ */
+/**
+ * Reconstruct .claude/settings.json and .windsurf/hooks.json from the union
+ * of all specified templates.
+ *
+ * The function:
+ * 1. Starts with empty settings
+ * 2. Merges _shared template settings (always included)
+ * 3. For each active template, merges its template-source settings
+ * 4. Writes the result to the IDE settings file
+ *
+ * Uses mergeClaudeSettings() from hooks-merger.ts for dedup-aware merging.
+ *
+ * Install calls: reconstructIdeSettings(targetDir, [...existingTemplates, newTemplate], ides)
+ * Clear calls:   reconstructIdeSettings(targetDir, existingTemplates.filter(t => t !== removed), ides)
+ *
+ * @param targetDir - Project root directory
+ * @param activeTemplates - Template names to include (e.g., ['cc-native', 'bmad'])
+ * @param ides - IDEs to reconstruct for (e.g., ['claude', 'windsurf'])
+ */
+export declare function reconstructIdeSettings(targetDir: string, activeTemplates: string[], ides: string[]): Promise<void>;