aiwcli 0.10.1 → 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/gitignore-manager.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Prune stale entries from the AIW Installation section in .gitignore.
+ * Checks each entry against disk existence and removes entries whose paths don't exist.
+ * Removes the entire section if no entries remain after pruning.
+ *
+ * @param targetDir - Directory containing .gitignore
+ * @returns True if any entries were pruned
+ */
+export declare function pruneGitignoreStaleEntries(targetDir: string): Promise<boolean>;
 /**
  * Update .gitignore with patterns for installed folders.
  *

package/dist/lib/gitignore-manager.js

@@ -1,5 +1,126 @@
 import { promises as fs } from 'node:fs';
 import { join } from 'node:path';
+import { pathExists } from './paths.js';
+/**
+ * AIW gitignore section header marker
+ */
+const AIW_GITIGNORE_HEADER = '# AIW Installation';
+/**
+ * Prune stale entries from the AIW Installation section in .gitignore.
+ * Checks each entry against disk existence and removes entries whose paths don't exist.
+ * Removes the entire section if no entries remain after pruning.
+ *
+ * @param targetDir - Directory containing .gitignore
+ * @returns True if any entries were pruned
+ */
+export async function pruneGitignoreStaleEntries(targetDir) {
+    const gitignorePath = join(targetDir, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf8');
+        if (!content.includes(AIW_GITIGNORE_HEADER)) {
+            return false;
+        }
+        const lines = content.split('\n');
+        const newLines = [];
+        let inAiwSection = false;
+        const aiwSectionLines = [];
+        let pruned = false;
+        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;
+                    const { lines: filtered, pruned: sectionPruned } = await pruneSection(aiwSectionLines, targetDir);
+                    if (sectionPruned)
+                        pruned = true;
+                    newLines.push(...filtered, line);
+                }
+                else {
+                    aiwSectionLines.push(line);
+                }
+            }
+            else {
+                newLines.push(line);
+            }
+        }
+        // Handle case where AIW section is at end of file
+        if (inAiwSection) {
+            const { lines: filtered, pruned: sectionPruned } = await pruneSection(aiwSectionLines, targetDir);
+            if (sectionPruned)
+                pruned = true;
+            newLines.push(...filtered);
+        }
+        if (!pruned) {
+            return false;
+        }
+        // Clean up: remove AIW section entirely if only header remains
+        let result = cleanupEmptySections(newLines.join('\n'));
+        // Ensure file ends properly
+        result = result.replace(/\n+$/, '\n');
+        if (result.trim() === '') {
+            result = '';
+        }
+        await fs.writeFile(gitignorePath, result, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Prune stale entries from a parsed AIW section.
+ * Checks each gitignore pattern against disk existence.
+ */
+async function pruneSection(sectionLines, targetDir) {
+    let pruned = false;
+    const filtered = [];
+    for (const line of sectionLines) {
+        // Always keep the header
+        if (line === AIW_GITIGNORE_HEADER) {
+            filtered.push(line);
+            continue;
+        }
+        // Check if the path exists on disk
+        const cleanPath = line.replace(/^\//, '').replace(/\/$/, '');
+        const absPath = join(targetDir, cleanPath);
+        if (await pathExists(absPath)) {
+            filtered.push(line);
+        }
+        else {
+            pruned = true;
+        }
+    }
+    return { lines: filtered, pruned };
+}
+/**
+ * Remove empty AIW sections (header with no patterns following).
+ */
+function cleanupEmptySections(content) {
+    const lines = content.split('\n');
+    const newLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === AIW_GITIGNORE_HEADER) {
+            // Look ahead to see if there are any patterns
+            const nextLine = lines[i + 1];
+            if (nextLine === undefined || nextLine === '' || nextLine.startsWith('#')) {
+                // Skip the header — section is empty
+                // Also remove trailing empty lines before the header
+                while (newLines.length > 0 && newLines.at(-1) === '') {
+                    newLines.pop();
+                }
+                continue;
+            }
+        }
+        newLines.push(line);
+    }
+    return newLines.join('\n');
+}
 /**
  * Update .gitignore with patterns for installed folders.
  *

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>;