claude-git-hooks 2.18.0 → 2.19.0

package/lib/commands/install.js

@@ -31,6 +31,7 @@ import {
     Entertainment
 } from './helpers.js';
 import { runSetupGitHub } from './setup-github.js';
+import { generateCompletionData } from '../cli-metadata.js';
 
 /**
  * Function to check version (used by hooks)
@@ -65,7 +66,7 @@ async function checkVersionAndPromptUpdate() {
                         success('Update completed. Please run your command again.');
                         process.exit(0); // Exit so user restarts the process
                     } catch (e) {
-                        error(`Error updating: ${  e.message}`);
+                        error(`Error updating: ${e.message}`);
                         resolve(false);
                     }
                 } else {
@@ -96,10 +97,14 @@ async function checkAndInstallClaude() {
         if (isWindows()) {
             console.log('\n⚠️  On Windows, Claude CLI must be installed in WSL:');
             console.log('1. Open WSL terminal (wsl or Ubuntu from Start Menu)');
-            console.log('2. Follow installation at: https://docs.anthropic.com/claude/docs/claude-cli');
+            console.log(
+                '2. Follow installation at: https://docs.anthropic.com/claude/docs/claude-cli'
+            );
             console.log('3. Verify with: wsl claude --version');
         } else {
-            console.log('\nClaude CLI installation: https://docs.anthropic.com/claude/docs/claude-cli');
+            console.log(
+                '\nClaude CLI installation: https://docs.anthropic.com/claude/docs/claude-cli'
+            );
         }
 
         console.log('\nAfter installation, run: claude-hooks install --force');
@@ -211,7 +216,7 @@ function updateGitignore() {
     const gitignorePath = '.gitignore';
     const claudeEntries = [
         '# Claude Git Hooks (includes .claude/settings.local.json for tokens)',
-        '.claude/',
+        '.claude/'
     ];
 
     let gitignoreContent = '';
@@ -225,7 +230,7 @@ function updateGitignore() {
 
     // Check which entries are missing
     const missingEntries = [];
-    claudeEntries.forEach(entry => {
+    claudeEntries.forEach((entry) => {
         if (entry.startsWith('#')) {
             // For comments, check if any Claude comment already exists
             if (!gitignoreContent.includes('# Claude')) {
@@ -253,7 +258,7 @@ function updateGitignore() {
         }
 
         // Add the missing entries
-        gitignoreContent += `${missingEntries.join('\n')  }\n`;
+        gitignoreContent += `${missingEntries.join('\n')}\n`;
 
         // Write the updated file
         fs.writeFileSync(gitignorePath, gitignoreContent);
@@ -265,7 +270,7 @@ function updateGitignore() {
         }
 
         // Show what was added
-        missingEntries.forEach(entry => {
+        missingEntries.forEach((entry) => {
             if (!entry.startsWith('#')) {
                 info(`  + ${entry}`);
             }
@@ -293,9 +298,8 @@ function configureGit() {
             execSync('git config core.autocrlf input', { stdio: 'ignore' });
             success('Line endings configured for Unix (core.autocrlf = input)');
         }
-
     } catch (e) {
-        warning(`Error configuring Git: ${  e.message}`);
+        warning(`Error configuring Git: ${e.message}`);
     }
 }
 
@@ -381,7 +385,9 @@ async function autoMigrateConfig(newConfigPath, backupConfigPath) {
  */
 export async function runInstall(args) {
     if (!checkGitRepo()) {
-        error('You are not in a Git repository. Please run this command from the root of a repository.');
+        error(
+            'You are not in a Git repository. Please run this command from the root of a repository.'
+        );
     }
 
     const isForce = args.includes('--force');
@@ -422,7 +428,7 @@ export async function runInstall(args) {
     // Hooks to install
     const hooks = ['pre-commit', 'prepare-commit-msg'];
 
-    hooks.forEach(hook => {
+    hooks.forEach((hook) => {
         const sourcePath = path.join(templatesPath, hook);
         const destPath = path.join(hooksPath, hook);
 
@@ -457,12 +463,9 @@ export async function runInstall(args) {
     }
 
     // Remove old SONAR template files if they exist (migration from v2.6.x to v2.7.0+)
-    const oldSonarFiles = [
-        'CLAUDE_PRE_COMMIT_SONAR.md',
-        'CLAUDE_ANALYSIS_PROMPT_SONAR.md'
-    ];
+    const oldSonarFiles = ['CLAUDE_PRE_COMMIT_SONAR.md', 'CLAUDE_ANALYSIS_PROMPT_SONAR.md'];
 
-    oldSonarFiles.forEach(oldFile => {
+    oldSonarFiles.forEach((oldFile) => {
         const oldPath = path.join(claudeDir, oldFile);
         if (fs.existsSync(oldPath)) {
             fs.unlinkSync(oldPath);
@@ -478,16 +481,17 @@ export async function runInstall(args) {
     }
 
     // Copy template files (.md and .json) to appropriate locations
-    const templateFiles = fs.readdirSync(templatesPath)
-        .filter(file => {
-            const filePath = path.join(templatesPath, file);
-            // Exclude example.json files and only include .md and .json files
-            return fs.statSync(filePath).isFile() &&
-                   (file.endsWith('.md') || file.endsWith('.json')) &&
-                   !file.includes('example.json');
-        });
+    const templateFiles = fs.readdirSync(templatesPath).filter((file) => {
+        const filePath = path.join(templatesPath, file);
+        // Exclude example.json files and only include .md and .json files
+        return (
+            fs.statSync(filePath).isFile() &&
+            (file.endsWith('.md') || file.endsWith('.json')) &&
+            !file.includes('example.json')
+        );
+    });
 
-    templateFiles.forEach(file => {
+    templateFiles.forEach((file) => {
         const sourcePath = path.join(templatesPath, file);
         let destPath;
         let destLocation;
@@ -514,14 +518,13 @@ export async function runInstall(args) {
 
     // Clean up old .md files from .claude/ root (v2.8.0 migration)
     // .md files should now be in .claude/prompts/, not .claude/
-    const oldMdFiles = fs.readdirSync(claudeDir)
-        .filter(file => {
-            const filePath = path.join(claudeDir, file);
-            return fs.statSync(filePath).isFile() && file.endsWith('.md');
-        });
+    const oldMdFiles = fs.readdirSync(claudeDir).filter((file) => {
+        const filePath = path.join(claudeDir, file);
+        return fs.statSync(filePath).isFile() && file.endsWith('.md');
+    });
 
     if (oldMdFiles.length > 0) {
-        oldMdFiles.forEach(file => {
+        oldMdFiles.forEach((file) => {
             const oldPath = path.join(claudeDir, file);
             fs.unlinkSync(oldPath);
             info(`Removed old template from .claude/: ${file} (now in prompts/)`);
@@ -539,10 +542,11 @@ export async function runInstall(args) {
         }
 
         // Copy each preset directory
-        const presetDirs = fs.readdirSync(presetsSourcePath)
-            .filter(item => fs.statSync(path.join(presetsSourcePath, item)).isDirectory());
+        const presetDirs = fs
+            .readdirSync(presetsSourcePath)
+            .filter((item) => fs.statSync(path.join(presetsSourcePath, item)).isDirectory());
 
-        presetDirs.forEach(presetName => {
+        presetDirs.forEach((presetName) => {
             const presetSource = path.join(presetsSourcePath, presetName);
             const presetDest = path.join(presetsDestPath, presetName);
 
@@ -553,7 +557,7 @@ export async function runInstall(args) {
 
             // Copy all files in preset directory
             const presetFiles = fs.readdirSync(presetSource);
-            presetFiles.forEach(file => {
+            presetFiles.forEach((file) => {
                 const sourceFile = path.join(presetSource, file);
                 const destFile = path.join(presetDest, file);
 
@@ -585,7 +589,7 @@ export async function runInstall(args) {
 
     // Copy example configs to config_example/ directly from templates/
     const exampleConfigs = ['config.example.json', 'config.advanced.example.json'];
-    exampleConfigs.forEach(exampleFile => {
+    exampleConfigs.forEach((exampleFile) => {
         const sourcePath = path.join(templatesPath, exampleFile);
         const destPath = path.join(configExampleDir, exampleFile);
         if (fs.existsSync(sourcePath)) {
@@ -634,7 +638,10 @@ export async function runInstall(args) {
         // Auto-run migration if needed to preserve settings
         if (needsMigration) {
             info('🔄 Auto-migrating settings from backup...');
-            await autoMigrateConfig(configPath, path.join(configOldDir, fs.readdirSync(configOldDir).sort().pop()));
+            await autoMigrateConfig(
+                configPath,
+                path.join(configOldDir, fs.readdirSync(configOldDir).sort().pop())
+            );
         }
     }
 
@@ -642,8 +649,8 @@ export async function runInstall(args) {
     const settingsLocalPath = path.join(claudeDir, 'settings.local.json');
     if (!fs.existsSync(settingsLocalPath)) {
         const settingsLocalContent = {
-            '_comment': 'Local settings - DO NOT COMMIT. This file is gitignored.',
-            'githubToken': ''
+            _comment: 'Local settings - DO NOT COMMIT. This file is gitignored.',
+            githubToken: ''
         };
         fs.writeFileSync(settingsLocalPath, JSON.stringify(settingsLocalContent, null, 2));
         info('settings.local.json created (add your GitHub token here)');
@@ -655,6 +662,9 @@ export async function runInstall(args) {
     // Update .gitignore
     updateGitignore();
 
+    // Install shell completions
+    installCompletions();
+
     success('Claude Git Hooks installed successfully! 🎉');
     console.log('\nRun claude-hooks --help to see all available commands.');
 
@@ -662,3 +672,500 @@ export async function runInstall(args) {
     console.log('');
     await runSetupGitHub();
 }
+
+// ── Shell completion generation ──────────────────────────────────────────────
+
+/**
+ * User-level paths for completion scripts
+ * @returns {{ bash: string, zsh: string, fish: string, powershell: string }}
+ */
+export function getCompletionPaths() {
+    const home = os.homedir();
+    return {
+        bash: path.join(home, '.local', 'share', 'bash-completion', 'completions', 'claude-hooks'),
+        zsh: path.join(home, '.zfunc', '_claude-hooks'),
+        fish: path.join(home, '.config', 'fish', 'completions', 'claude-hooks.fish'),
+        powershell: path.join(home, '.config', 'powershell', 'completions', 'claude-hooks.ps1')
+    };
+}
+
+/**
+ * Get PowerShell profile path by querying PowerShell's $PROFILE variable.
+ * Why: Hardcoding ~/Documents/PowerShell/ breaks on OneDrive-redirected or locale-specific
+ * Documents folders (e.g., "OneDrive - Corp/Documentos/WindowsPowerShell/").
+ * Falls back to conventional paths if the query fails.
+ * @returns {string}
+ */
+export function getPowerShellProfilePath() {
+    const home = os.homedir();
+    const isWindows = os.platform() === 'win32' || process.env.OS === 'Windows_NT';
+
+    if (isWindows) {
+        // Ask PowerShell itself for the correct $PROFILE path
+        // This handles OneDrive redirection, localized folder names, and pwsh vs PS 5.1
+        for (const shell of ['pwsh', 'powershell.exe']) {
+            try {
+                const profilePath = execSync(`${shell} -NoProfile -Command "$PROFILE"`, {
+                    encoding: 'utf8',
+                    timeout: 5000,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+                if (profilePath && profilePath.endsWith('.ps1')) {
+                    return profilePath;
+                }
+            } catch {
+                // Shell not available or timed out, try next
+            }
+        }
+        // Fallback: conventional paths if PowerShell query fails
+        const psCorePath = path.join(
+            home,
+            'Documents',
+            'PowerShell',
+            'Microsoft.PowerShell_profile.ps1'
+        );
+        if (fs.existsSync(path.dirname(psCorePath))) {
+            return psCorePath;
+        }
+        return path.join(
+            home,
+            'Documents',
+            'WindowsPowerShell',
+            'Microsoft.PowerShell_profile.ps1'
+        );
+    }
+    return path.join(home, '.config', 'powershell', 'Microsoft.PowerShell_profile.ps1');
+}
+
+/**
+ * Generate Bash completion script from completion data
+ * @param {Object} data - Flat completion data from generateCompletionData()
+ * @returns {string}
+ */
+export function generateBashCompletion(data) {
+    const allCommands = data.commands.join(' ');
+
+    // Build per-command flag/arg cases
+    const cases = [];
+    for (const cmd of data.commands) {
+        const parts = [];
+        if (data.flags[cmd]) {
+            parts.push(...data.flags[cmd]);
+        }
+        if (data.subcommands[cmd]) {
+            parts.push(...data.subcommands[cmd]);
+        }
+        if (data.argValues[cmd]) {
+            parts.push(...data.argValues[cmd]);
+        }
+        if (parts.length > 0) {
+            cases.push(
+                `        ${cmd})\n            COMPREPLY=( $(compgen -W "${parts.join(' ')}" -- "$cur") )\n            return 0\n            ;;`
+            );
+        }
+        // Dynamic branch completion
+        if (data.argCompletions[cmd]) {
+            cases.push(
+                `        ${cmd})\n            local branches\n            branches=$(${data.argCompletions[cmd]} 2>/dev/null)\n            COMPREPLY=( $(compgen -W "$branches" -- "$cur") )\n            return 0\n            ;;`
+            );
+        }
+    }
+
+    return `# Bash completion for claude-hooks
+# Generated by claude-hooks install — do not edit manually
+_claude_hooks_completions() {
+    local cur prev commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    commands="${allCommands}"
+
+    if [[ \${COMP_CWORD} -eq 1 ]]; then
+        COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+        return 0
+    fi
+
+    case "$prev" in
+${cases.join('\n')}
+    esac
+
+    return 0
+}
+complete -F _claude_hooks_completions claude-hooks
+`;
+}
+
+/**
+ * Generate Zsh completion script from completion data
+ * @param {Object} data - Flat completion data from generateCompletionData()
+ * @returns {string}
+ */
+export function generateZshCompletion(data) {
+    // Build command descriptions for _describe
+    const cmdDescs = data.commands
+        .filter((c) => !c.startsWith('-'))
+        .map((c) => `'${c}:${(data.descriptions[c] || '').replace(/'/g, "\\'")}'`)
+        .join('\n        ');
+
+    // Build per-command completions
+    const subcases = [];
+    for (const cmd of data.commands) {
+        if (cmd.startsWith('-')) continue;
+        const parts = [];
+        if (data.flags[cmd]) {
+            for (const flag of data.flags[cmd]) {
+                const desc = '';
+                parts.push(`'${flag}[${desc}]'`);
+            }
+        }
+        if (data.subcommands[cmd]) {
+            parts.push(`'(${data.subcommands[cmd].join(' ')})'`);
+        }
+        if (data.argValues[cmd]) {
+            parts.push(`'(${data.argValues[cmd].join(' ')})'`);
+        }
+        if (data.argCompletions[cmd]) {
+            subcases.push(
+                `        ${cmd})\n            local branches\n            branches=(\${(f)"$(${data.argCompletions[cmd]} 2>/dev/null)"})\n            _describe 'branch' branches\n            ;;`
+            );
+            continue;
+        }
+        if (parts.length > 0) {
+            subcases.push(
+                `        ${cmd})\n            _arguments ${parts.join(' ')}\n            ;;`
+            );
+        }
+    }
+
+    return `#compdef claude-hooks
+# Zsh completion for claude-hooks
+# Generated by claude-hooks install — do not edit manually
+
+_claude-hooks() {
+    local -a commands
+    commands=(
+        ${cmdDescs}
+    )
+
+    _arguments '1:command:->cmds' '*:arg:->args'
+
+    case $state in
+    cmds)
+        _describe 'command' commands
+        ;;
+    args)
+        case $words[2] in
+${subcases.join('\n')}
+        esac
+        ;;
+    esac
+}
+
+_claude-hooks "$@"
+`;
+}
+
+/**
+ * Generate Fish completion script from completion data
+ * @param {Object} data - Flat completion data from generateCompletionData()
+ * @returns {string}
+ */
+export function generateFishCompletion(data) {
+    const lines = [
+        '# Fish completion for claude-hooks',
+        '# Generated by claude-hooks install — do not edit manually',
+        '',
+        '# Disable file completions by default',
+        'complete -c claude-hooks -f',
+        ''
+    ];
+
+    // Top-level commands
+    for (const cmd of data.commands) {
+        if (cmd.startsWith('-')) continue;
+        const desc = data.descriptions[cmd] || '';
+        lines.push(
+            `complete -c claude-hooks -n '__fish_use_subcommand' -a '${cmd}' -d '${desc.replace(/'/g, "\\'")}'`
+        );
+    }
+
+    lines.push('');
+
+    // Per-command flags and subcommands
+    for (const cmd of data.commands) {
+        if (cmd.startsWith('-')) continue;
+
+        if (data.flags[cmd]) {
+            for (const flag of data.flags[cmd]) {
+                const flagName = flag.replace(/^--/, '');
+                lines.push(
+                    `complete -c claude-hooks -n '__fish_seen_subcommand_from ${cmd}' -l '${flagName}' -d '${(data.descriptions[cmd] || '').replace(/'/g, "\\'")}'`
+                );
+            }
+        }
+
+        if (data.subcommands[cmd]) {
+            for (const sub of data.subcommands[cmd]) {
+                lines.push(
+                    `complete -c claude-hooks -n '__fish_seen_subcommand_from ${cmd}' -a '${sub}'`
+                );
+            }
+        }
+
+        if (data.argValues[cmd]) {
+            for (const val of data.argValues[cmd]) {
+                lines.push(
+                    `complete -c claude-hooks -n '__fish_seen_subcommand_from ${cmd}' -a '${val}'`
+                );
+            }
+        }
+
+        if (data.argCompletions[cmd]) {
+            lines.push(
+                `complete -c claude-hooks -n '__fish_seen_subcommand_from ${cmd}' -a '(${data.argCompletions[cmd]} 2>/dev/null)'`
+            );
+        }
+    }
+
+    lines.push('');
+    return lines.join('\n');
+}
+
+/**
+ * Generate PowerShell completion script from completion data
+ * @param {Object} data - Flat completion data from generateCompletionData()
+ * @returns {string}
+ */
+export function generatePowerShellCompletion(data) {
+    const allCommands = data.commands.map((c) => `'${c}'`).join(', ');
+
+    // Build per-command switch cases
+    const cases = [];
+    for (const cmd of data.commands) {
+        const completions = [];
+        if (data.flags[cmd]) {
+            for (const flag of data.flags[cmd]) {
+                completions.push(
+                    `[System.Management.Automation.CompletionResult]::new('${flag}', '${flag}', [System.Management.Automation.CompletionResultType]::ParameterName, '${(data.descriptions[cmd] || '').replace(/'/g, "''")}')`
+                );
+            }
+        }
+        if (data.subcommands[cmd]) {
+            for (const sub of data.subcommands[cmd]) {
+                completions.push(
+                    `[System.Management.Automation.CompletionResult]::new('${sub}', '${sub}', [System.Management.Automation.CompletionResultType]::ParameterValue, '${sub}')`
+                );
+            }
+        }
+        if (data.argValues[cmd]) {
+            for (const val of data.argValues[cmd]) {
+                completions.push(
+                    `[System.Management.Automation.CompletionResult]::new('${val}', '${val}', [System.Management.Automation.CompletionResultType]::ParameterValue, '${val}')`
+                );
+            }
+        }
+        if (completions.length > 0) {
+            cases.push(
+                `        '${cmd}' {\n            ${completions.join('\n            ')}\n        }`
+            );
+        }
+    }
+
+    return `# PowerShell completion for claude-hooks
+# Generated by claude-hooks install — do not edit manually
+
+# PS 5.1 workaround: -Native completers don't fire for ExternalScript commands (.ps1 npm shims).
+# Wrapping in a function makes PowerShell resolve it as Function type, which -Native completers support.
+if ((Get-Command claude-hooks -ErrorAction SilentlyContinue).CommandType -eq 'ExternalScript') {
+    $script:_claudeHooksOriginalPath = (Get-Command claude-hooks -CommandType ExternalScript).Source
+    function global:claude-hooks { & $script:_claudeHooksOriginalPath @args }
+}
+
+Register-ArgumentCompleter -CommandName claude-hooks -Native -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    $commands = @(${allCommands})
+    $tokens = $commandAst.ToString().Split()
+    # .Split() drops trailing empty entries — detect cursor past last token
+    $position = $tokens.Count
+    if ($commandAst.ToString() -match '\\s$') { $position++ }
+
+    if ($position -le 2) {
+        $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, [System.Management.Automation.CompletionResultType]::ParameterValue, $_)
+        }
+        return
+    }
+
+    $cmd = $tokens[1]
+    switch ($cmd) {
+${cases.join('\n')}
+    }
+}
+`;
+}
+
+/**
+ * Ensure a marker+line pair exists in an rc file, replacing stale content if needed.
+ * Idempotent: skips write if marker and line already match exactly.
+ * Self-healing: replaces the line after the marker if content has changed (e.g., backslash → $HOME paths).
+ * @param {string} filePath - Absolute path to rc file
+ * @param {string} marker - Unique comment marker to identify our block
+ * @param {string} line - The line to place after the marker
+ */
+function appendLineIfMissing(filePath, marker, line) {
+    let content = '';
+    if (fs.existsSync(filePath)) {
+        content = fs.readFileSync(filePath, 'utf8');
+    }
+    if (content.includes(marker)) {
+        // Marker exists — check if the line after it matches the desired content
+        const markerLineRegex = new RegExp(
+            `${marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n[^\\n]*`
+        );
+        const match = content.match(markerLineRegex);
+        if (match && match[0] === `${marker}\n${line}`) {
+            return; // Already correct
+        }
+        // Replace stale line after marker with the correct one
+        content = content.replace(markerLineRegex, `${marker}\n${line}`);
+        fs.writeFileSync(filePath, content);
+        return;
+    }
+    const newline = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+    fs.appendFileSync(filePath, `${newline}\n${marker}\n${line}\n`);
+}
+
+/**
+ * Install shell completion scripts for all supported shells
+ * Reads command metadata and generates completion scripts to user-level paths.
+ * Uses $HOME-relative paths in source lines to avoid backslash issues on Windows/MINGW64.
+ * Wrapped in try/catch — warns on failure, never blocks install.
+ */
+export function installCompletions() {
+    try {
+        const data = generateCompletionData();
+        const paths = getCompletionPaths();
+        let installed = 0;
+
+        // Bash
+        try {
+            fs.mkdirSync(path.dirname(paths.bash), { recursive: true });
+            fs.writeFileSync(paths.bash, generateBashCompletion(data));
+            // Use $HOME-relative path in source line (forward slashes)
+            // Why: path.join() produces backslash paths on Windows, which MINGW64 bash can't interpret
+            const bashRelPath = '.local/share/bash-completion/completions/claude-hooks';
+            const bashSourceLine = `[ -f "$HOME/${bashRelPath}" ] && source "$HOME/${bashRelPath}"`;
+            // Write to both .bashrc and .bash_profile for maximum compatibility
+            // Why: MINGW64/Git Bash reads .bash_profile first; some setups don't source .bashrc from it
+            const home = os.homedir();
+            const bashrc = path.join(home, '.bashrc');
+            appendLineIfMissing(bashrc, '# claude-hooks completions', bashSourceLine);
+            const bashProfile = path.join(home, '.bash_profile');
+            if (fs.existsSync(bashProfile)) {
+                appendLineIfMissing(
+                    bashProfile,
+                    '# claude-hooks completions',
+                    bashSourceLine
+                );
+            }
+            installed++;
+        } catch (e) {
+            warning(`Bash completions: ${e.message}`);
+        }
+
+        // Zsh
+        try {
+            fs.mkdirSync(path.dirname(paths.zsh), { recursive: true });
+            fs.writeFileSync(paths.zsh, generateZshCompletion(data));
+            const zshrc = path.join(os.homedir(), '.zshrc');
+            appendLineIfMissing(
+                zshrc,
+                '# claude-hooks completions',
+                'fpath=(~/.zfunc $fpath); autoload -Uz compinit && compinit'
+            );
+            installed++;
+        } catch (e) {
+            warning(`Zsh completions: ${e.message}`);
+        }
+
+        // Fish
+        try {
+            fs.mkdirSync(path.dirname(paths.fish), { recursive: true });
+            fs.writeFileSync(paths.fish, generateFishCompletion(data));
+            installed++;
+        } catch (e) {
+            warning(`Fish completions: ${e.message}`);
+        }
+
+        // PowerShell
+        try {
+            fs.mkdirSync(path.dirname(paths.powershell), { recursive: true });
+            fs.writeFileSync(paths.powershell, generatePowerShellCompletion(data));
+            // Use $HOME-relative path with forward slashes (PowerShell supports both separators)
+            const psRelPath = '.config/powershell/completions/claude-hooks.ps1';
+            const psProfile = getPowerShellProfilePath();
+            try {
+                fs.mkdirSync(path.dirname(psProfile), { recursive: true });
+                appendLineIfMissing(
+                    psProfile,
+                    '# claude-hooks completions',
+                    `. "$HOME/${psRelPath}"`
+                );
+            } catch (e) {
+                warning(`PowerShell profile: ${e.message}`);
+            }
+            installed++;
+        } catch (e) {
+            warning(`PowerShell completions: ${e.message}`);
+        }
+
+        if (installed > 0) {
+            success(`Shell completions installed (${installed} shells)`);
+            info('Restart your shell or open a new terminal for completions to take effect.');
+        }
+    } catch (e) {
+        warning(`Shell completions: ${e.message}`);
+    }
+}
+
+/**
+ * Remove shell completion scripts and rc file modifications
+ * Called by runUninstall() for cleanup.
+ */
+export function removeCompletions() {
+    const paths = getCompletionPaths();
+
+    // Remove completion files
+    for (const [shell, filePath] of Object.entries(paths)) {
+        try {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+        } catch (e) {
+            warning(`Could not remove ${shell} completion: ${e.message}`);
+        }
+    }
+
+    // Clean rc files (bashrc, bash_profile, zshrc, PowerShell profile)
+    const rcFiles = [
+        path.join(os.homedir(), '.bashrc'),
+        path.join(os.homedir(), '.bash_profile'),
+        path.join(os.homedir(), '.zshrc'),
+        getPowerShellProfilePath()
+    ];
+
+    for (const rcFile of rcFiles) {
+        try {
+            if (fs.existsSync(rcFile)) {
+                let content = fs.readFileSync(rcFile, 'utf8');
+                const marker = '# claude-hooks completions';
+                if (content.includes(marker)) {
+                    content = content.replace(/\n?# claude-hooks completions\n[^\n]*\n?/g, '\n');
+                    fs.writeFileSync(rcFile, content);
+                }
+            }
+        } catch (e) {
+            warning(`Could not clean ${path.basename(rcFile)}: ${e.message}`);
+        }
+    }
+}