aiwcli 0.10.2 → 0.11.0

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

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 { AIW_GITIGNORE_ENTRIES, updateGitignore } from '../../lib/gitignore-manager.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,14 +107,11 @@ 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']);
+                    await updateGitignore(targetDir, [...AIW_GITIGNORE_ENTRIES]);
                     this.logSuccess('✓ .gitignore updated');
                 }
                 this.log('');
@@ -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,20 +175,14 @@ 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'];
+            const foldersForGitignore = [...AIW_GITIGNORE_ENTRIES];
             // Report installation results
             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,7 @@
+/** Standard gitignore entries managed by AIW */
+export declare const AIW_GITIGNORE_ENTRIES: string[];
+/** Entries that should NEVER be removed from gitignore, even on clear */
+export declare const AIW_PERMANENT_ENTRIES: string[];
 /**
  * Prune stale entries from the AIW Installation section in .gitignore.
  * Checks each entry against disk existence and removes entries whose paths don't exist.
@@ -17,3 +21,31 @@ export declare function pruneGitignoreStaleEntries(targetDir: string): Promise<b
  * @param folders - List of folder names to add as gitignore patterns (e.g., ['_bmad', '.claude'])
  */
 export declare function updateGitignore(targetDir: string, folders: string[]): Promise<void>;
+/**
+ * Compute which AIW gitignore entries should be removed during clear.
+ * Returns a simulation result — the caller decides whether to apply.
+ *
+ * Logic per entry:
+ * - If in permanentEntries → keep (reason: "permanent")
+ * - If directory exists and is non-empty → keep (reason: "directory has content")
+ * - Otherwise → mark for removal
+ *
+ * @param targetDir - Directory containing .gitignore
+ * @param permanentEntries - Entries that should never be removed (defaults to AIW_PERMANENT_ENTRIES)
+ * @returns Lists of entries to remove and entries to keep with reasons
+ */
+export declare function computeGitignoreRemovals(targetDir: string, permanentEntries?: string[]): Promise<{
+    toKeep: Array<{
+        entry: string;
+        reason: string;
+    }>;
+    toRemove: string[];
+}>;
+/**
+ * Remove specific entries from the AIW section in .gitignore.
+ * Cleans up the section header if no entries remain.
+ *
+ * @param targetDir - Directory containing .gitignore
+ * @param entriesToRemove - Entry names to remove (without trailing slash)
+ */
+export declare function removeGitignoreEntries(targetDir: string, entriesToRemove: string[]): Promise<void>;

package/dist/lib/gitignore-manager.js

@@ -5,6 +5,10 @@ import { pathExists } from './paths.js';
  * AIW gitignore section header marker
  */
 const AIW_GITIGNORE_HEADER = '# AIW Installation';
+/** Standard gitignore entries managed by AIW */
+export const AIW_GITIGNORE_ENTRIES = ['.aiwcli', '_output', '.claude', '.windsurf'];
+/** Entries that should NEVER be removed from gitignore, even on clear */
+export const AIW_PERMANENT_ENTRIES = ['_output'];
 /**
  * Prune stale entries from the AIW Installation section in .gitignore.
  * Checks each entry against disk existence and removes entries whose paths don't exist.
@@ -35,7 +39,7 @@ export async function pruneGitignoreStaleEntries(targetDir) {
                 // 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);
+                    const { lines: filtered, pruned: sectionPruned } = await pruneSection(aiwSectionLines, targetDir); // eslint-disable-line no-await-in-loop
                     if (sectionPruned)
                         pruned = true;
                     newLines.push(...filtered, line);
@@ -88,7 +92,7 @@ async function pruneSection(sectionLines, targetDir) {
         // Check if the path exists on disk
         const cleanPath = line.replace(/^\//, '').replace(/\/$/, '');
         const absPath = join(targetDir, cleanPath);
-        if (await pathExists(absPath)) {
+        if (await pathExists(absPath)) { // eslint-disable-line no-await-in-loop
             filtered.push(line);
         }
         else {
@@ -179,3 +183,138 @@ export async function updateGitignore(targetDir, folders) {
         await fs.writeFile(gitignorePath, patternsBlock + '\n', 'utf8');
     }
 }
+/**
+ * Compute which AIW gitignore entries should be removed during clear.
+ * Returns a simulation result — the caller decides whether to apply.
+ *
+ * Logic per entry:
+ * - If in permanentEntries → keep (reason: "permanent")
+ * - If directory exists and is non-empty → keep (reason: "directory has content")
+ * - Otherwise → mark for removal
+ *
+ * @param targetDir - Directory containing .gitignore
+ * @param permanentEntries - Entries that should never be removed (defaults to AIW_PERMANENT_ENTRIES)
+ * @returns Lists of entries to remove and entries to keep with reasons
+ */
+export async function computeGitignoreRemovals(targetDir, permanentEntries = AIW_PERMANENT_ENTRIES) {
+    const gitignorePath = join(targetDir, '.gitignore');
+    const toRemove = [];
+    const toKeep = [];
+    // Read AIW section entries from .gitignore
+    let content;
+    try {
+        content = await fs.readFile(gitignorePath, 'utf8');
+    }
+    catch {
+        return { toRemove, toKeep };
+    }
+    if (!content.includes(AIW_GITIGNORE_HEADER)) {
+        return { toRemove, toKeep };
+    }
+    // Parse entries from the AIW section
+    const lines = content.split('\n');
+    let inAiwSection = false;
+    const aiwEntries = [];
+    for (const line of lines) {
+        if (line === AIW_GITIGNORE_HEADER) {
+            inAiwSection = true;
+            continue;
+        }
+        if (inAiwSection) {
+            if (line === '' || (line.startsWith('#') && line !== AIW_GITIGNORE_HEADER)) {
+                inAiwSection = false;
+            }
+            else {
+                // Strip trailing slash to get the directory name
+                const entry = line.replace(/\/$/, '');
+                if (entry) {
+                    aiwEntries.push(entry);
+                }
+            }
+        }
+    }
+    const permanentSet = new Set(permanentEntries);
+    // Evaluate each entry
+    await Promise.all(aiwEntries.map(async (entry) => {
+        if (permanentSet.has(entry)) {
+            toKeep.push({ entry, reason: 'permanent' });
+            return;
+        }
+        const dirPath = join(targetDir, entry);
+        const exists = await pathExists(dirPath);
+        if (exists) {
+            // Check if non-empty
+            try {
+                const entries = await fs.readdir(dirPath);
+                if (entries.length > 0) {
+                    toKeep.push({ entry, reason: 'directory has content' });
+                    return;
+                }
+            }
+            catch {
+                // Can't read — be safe, keep it
+                toKeep.push({ entry, reason: 'directory has content' });
+                return;
+            }
+        }
+        toRemove.push(entry);
+    }));
+    return { toRemove, toKeep };
+}
+/**
+ * Remove specific entries from the AIW section in .gitignore.
+ * Cleans up the section header if no entries remain.
+ *
+ * @param targetDir - Directory containing .gitignore
+ * @param entriesToRemove - Entry names to remove (without trailing slash)
+ */
+export async function removeGitignoreEntries(targetDir, entriesToRemove) {
+    const gitignorePath = join(targetDir, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf8');
+        if (!content.includes(AIW_GITIGNORE_HEADER)) {
+            return;
+        }
+        const patternsToRemove = new Set(entriesToRemove.map((e) => `${e}/`));
+        const lines = content.split('\n');
+        const newLines = [];
+        let inAiwSection = false;
+        const aiwSectionLines = [];
+        for (const line of lines) {
+            if (line === AIW_GITIGNORE_HEADER) {
+                inAiwSection = true;
+                aiwSectionLines.push(line);
+                continue;
+            }
+            if (inAiwSection) {
+                if (line === '' || (line.startsWith('#') && line !== AIW_GITIGNORE_HEADER)) {
+                    inAiwSection = false;
+                    // Filter the AIW section
+                    const filtered = aiwSectionLines.filter((l) => l === AIW_GITIGNORE_HEADER || !patternsToRemove.has(l));
+                    newLines.push(...filtered, line);
+                }
+                else {
+                    aiwSectionLines.push(line);
+                }
+            }
+            else {
+                newLines.push(line);
+            }
+        }
+        // Handle AIW section at end of file
+        if (inAiwSection) {
+            const filtered = aiwSectionLines.filter((l) => l === AIW_GITIGNORE_HEADER || !patternsToRemove.has(l));
+            newLines.push(...filtered);
+        }
+        // Clean up empty AIW section
+        let result = cleanupEmptySections(newLines.join('\n'));
+        result = result.replace(/\n+$/, '\n');
+        if (result.trim() === '') {
+            result = '';
+        }
+        await fs.writeFile(gitignorePath, result, 'utf8');
+    }
+    catch {
+        // .gitignore doesn't exist or can't be read
+    }
+}

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