@dtt_siye/atool 1.1.0

package/lib/install-cursor.sh

@@ -0,0 +1,281 @@
+#!/usr/bin/env bash
+# aTool - lib/install-cursor.sh
+# Cursor IDE installation (skills -> .mdc rules)
+
+set -euo pipefail
+
+# These functions are sourced by the parent script, not run directly.
+# common.sh must already be loaded.
+
+# Get file-type globs for a skill so Cursor auto-loads it for relevant files
+# Args: SKILL_NAME
+# Outputs: comma-separated glob list (e.g. "*.java,pom.xml")
+get_skill_globs() {
+    local skill_name="$1"
+    case "$skill_name" in
+        # Conventions skills - match their file types
+        java-conventions)       echo "*.java,pom.xml,*.gradle,*.gradle.kts" ;;
+        web-conventions)        echo "*.tsx,*.ts,*.jsx,*.js,*.vue,*.svelte,package.json" ;;
+        python-conventions)     echo "*.py,pyproject.toml,requirements.txt,setup.py" ;;
+        rust-conventions)       echo "*.rs,Cargo.toml,Cargo.lock" ;;
+        go-conventions)         echo "*.go,go.mod,go.sum" ;;
+        android-conventions)    echo "*.kt,*.kts,build.gradle,AndroidManifest.xml" ;;
+        harmony-conventions)    echo "*.ets,*.ts,oh-package.json5,build-profile.json5" ;;
+        swift-conventions)      echo "*.swift,Package.swift" ;;
+        flutter-conventions)    echo "*.dart,pubspec.yaml,analysis_options.yaml" ;;
+        react-native-conventions) echo "*.tsx,*.ts,*.jsx,*.js,app.json,metro.config.*" ;;
+        devops-conventions)     echo "Dockerfile,docker-compose.*,*.tf,Chart.yaml" ;;
+        # Analysis skills - trigger on code/doc files
+        project-analyze)        echo "*.md,CLAUDE.md,README.md" ;;
+        project-query)          echo "*.md,knowledge-graph.json" ;;
+        code-review)            echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.swift,*.kt,*.dart" ;;
+        # Workflow skills - trigger on markdown/planning files
+        writing-plans)          echo "*.md" ;;
+        executing-plans)        echo "*.md" ;;
+        brainstorming)          echo "*.md" ;;
+        systematic-debugging)   echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.swift,*.kt" ;;
+        verification-before-completion) echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.swift,*.kt" ;;
+        # Architecture/design
+        software-architecture)   echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.kt,*.swift,*.dart,*.ets,*.yaml,*.yml,*.md" ;;
+        ai-project-architecture) echo "*.py,pyproject.toml" ;;
+        doc-coauthoring)        echo "*.md" ;;
+        doc-standards-enforcer) echo "*.md" ;;
+        requirements-writer)    echo "*.md" ;;
+        ui-ux-pro)              echo "*.tsx,*.ts,*.jsx,*.js,*.vue,*.svelte,*.css,*.scss" ;;
+        webapp-testing)         echo "*.test.*,*.spec.*,playwright.config.*" ;;
+        find-skills)            echo "*.md,*.txt" ;;
+        smart-dispatch)         echo "*.plan.md" ;;
+        # Office skills
+        pdf)                    echo "*.pdf" ;;
+        docx)                   echo "*.docx" ;;
+        pptx)                   echo "*.pptx" ;;
+        xlsx)                   echo "*.xlsx,*.xlsm,*.csv,*.tsv" ;;
+        # Superpowers - broad globs for code-related
+        test-driven-development) echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.swift,*.kt" ;;
+        receiving-code-review)  echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.swift,*.kt" ;;
+        requesting-code-review) echo "*.java,*.py,*.ts,*.tsx,*.js,*.go,*.rs,*.swift,*.kt" ;;
+        finishing-a-development-branch) echo "*.md" ;;
+        dispatching-parallel-agents) echo "*.plan.md" ;;
+        subagent-driven-development) echo "*.plan.md" ;;
+        using-git-worktrees)    echo "" ;;
+        writing-skills)         echo "SKILL.md,*.skill.md" ;;
+        *)                      echo "" ;;
+    esac
+}
+
+# Determine whether a skill should use alwaysApply: true in .mdc
+# Only truly essential context skills — everything else uses globs or on-demand
+# Args: SKILL_NAME
+# Returns: 0 (true / always apply), 1 (false)
+should_always_apply() {
+    local skill_name="$1"
+    case "$skill_name" in
+        # Must-always: core context injected into every conversation
+        atool-init)                 return 0 ;;
+        using-superpowers)          return 0 ;;
+        clarify-before-build)       return 0 ;;
+        # Core workflow skills that Cursor users can't invoke via slash commands
+        # Must be always-on so the AI knows when to trigger them
+        project-analyze)           return 0 ;;
+        # Workflow skill with no good glob match - must be always-on
+        using-git-worktrees)       return 0 ;;
+        # Conventions skills - always relevant for their file types (via globs too)
+        *-conventions)              return 0 ;;
+        # All other skills: use globs or on-demand (reduces context token consumption)
+        *)                          return 1 ;;
+    esac
+}
+
+# Convert a SKILL.md to Cursor .mdc format
+# Args: SKILL_DIR, OUTPUT_FILE
+skill_to_mdc() {
+    local skill_dir="$1"
+    local output_file="$2"
+    local skill_name
+    skill_name=$(basename "$skill_dir")
+
+    local skill_md="$skill_dir/SKILL.md"
+    if [[ ! -f "$skill_md" ]]; then
+        return 1
+    fi
+
+    # Extract description from frontmatter or first heading
+    local description
+    description=$(sed -n '/^---$/,/^---$/p' "$skill_md" | grep '^description:' | head -1 | sed 's/^description:[[:space:]]*//' )
+    if [[ -z "$description" ]]; then
+        description=$(head -10 "$skill_md" | grep -i '^#' | head -1 | sed 's/^#*\s*//' || echo "$skill_name skill")
+    fi
+
+    # Determine globs and alwaysApply
+    local globs
+    globs=$(get_skill_globs "$skill_name")
+    local apply_flag="false"
+    if should_always_apply "$skill_name"; then
+        apply_flag="true"
+    fi
+
+    # Write frontmatter
+    echo "---" > "$output_file"
+    local escaped_desc
+    escaped_desc=$(printf '%s' "$description" | sed 's/"/\\"/g')
+    printf 'description: "%s"\n' "$escaped_desc" >> "$output_file"
+    if [[ -n "$globs" ]]; then
+        # Convert comma-separated to YAML list
+        echo "globs:" >> "$output_file"
+        local IFS_OLD="$IFS"
+        IFS=','
+        for glob in $globs; do
+            echo "  - \"$glob\"" >> "$output_file"
+        done
+        IFS="$IFS_OLD"
+    else
+        echo "globs:" >> "$output_file"
+    fi
+    echo "alwaysApply: $apply_flag" >> "$output_file"
+    echo "---" >> "$output_file"
+
+    # Add aTool marker
+    echo "# Added by aTool - DO NOT EDIT (auto-generated from skill: $skill_name)" >> "$output_file"
+    echo "" >> "$output_file"
+
+    # Append skill content, stripping YAML front matter from source
+    awk '/^---$/{n++;next} n<2{next} {print}' "$skill_md" >> "$output_file"
+}
+
+# Generate .mdc rules from skills into a target directory
+# Args: TARGET_DIR, SKILLS_DIRS...
+generate_cursor_skill_rules() {
+    local target_dir="$1"
+    shift
+    local skills_dirs=("$@")
+
+    ensure_dir "$target_dir"
+
+    for skills_base in "${skills_dirs[@]}"; do
+        [[ ! -d "$skills_base" ]] && continue
+        for skill_dir in "$skills_base"/*/; do
+            [[ ! -d "$skill_dir" ]] && continue
+            local skill_name
+            skill_name=$(basename "$skill_dir")
+            # Skip _superpowers and symlinks
+            [[ "$skill_name" == "_superpowers" ]] && continue
+            [[ -L "$skill_dir" ]] && continue
+            local mdc_file="$target_dir/atool-${skill_name}.mdc"
+
+            # Always generate to temp, compare checksums, update only if changed
+            local tmp_file
+            tmp_file=$(mktemp)
+
+            if skill_to_mdc "$skill_dir" "$tmp_file"; then
+                if [[ -f "$mdc_file" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+                    local existing_cksum new_cksum
+                    existing_cksum=$(file_checksum "$mdc_file")
+                    new_cksum=$(file_checksum "$tmp_file")
+                    if [[ "$existing_cksum" == "$new_cksum" ]]; then
+                        rm -f "$tmp_file"
+                        continue  # Content unchanged
+                    fi
+                    log_info "Rule '$skill_name' content changed, updating"
+                fi
+                mv "$tmp_file" "$mdc_file"
+                log_info "Generated rule: atool-${skill_name}.mdc"
+            else
+                rm -f "$tmp_file"
+            fi
+        done
+    done
+}
+
+install_cursor() {
+    log_step "Installing to Cursor..."
+
+    # Check if Cursor is installed
+    if ! command -v cursor &>/dev/null; then
+        local _cursor_dir
+        _cursor_dir=$(get_cursor_config_dir 2>/dev/null)
+        if [[ ! -d "$_cursor_dir" ]]; then
+            log_warn "Cursor not found in PATH and config directory does not exist"
+            log_info "Install Cursor first: https://cursor.sh"
+            if ! confirm "Continue anyway?" "N"; then
+                return 0
+            fi
+        fi
+    fi
+
+    local atool_root="${ATOOL_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+    local atool_skills_dir="$atool_root/skills"
+    local sp_dir=""
+
+    # Cursor only loads rules from PROJECT-LEVEL .cursor/rules/
+    # Global install generates rules to a staging area (<cursor_config>/rules/.atool-staging/)
+    # These are copied to project .cursor/rules/ when --project init runs
+    local cursor_config_dir
+    cursor_config_dir=$(get_cursor_config_dir)
+    local staging_dir="$cursor_config_dir/rules/.atool-staging"
+
+    # 1. Generate aTool rules to staging area
+    log_step "Generating aTool Cursor rules (staging)..."
+    generate_cursor_skill_rules "$staging_dir" "$atool_skills_dir"
+
+    # 2. Generate Superpowers rules to staging area
+    log_step "Generating Superpowers Cursor rules (staging)..."
+    local sp_submodule="$atool_root/skills/_superpowers"
+
+    if [[ -d "$sp_submodule/skills" ]]; then
+        # Use local submodule
+        sp_dir="$sp_submodule"
+        log_info "Using local Superpowers submodule"
+    else
+        # Fallback: download from GitHub
+        log_warn "Superpowers submodule not found, downloading..."
+        sp_dir="$HOME/.atool/cache/superpowers"
+        download_superpowers "$sp_dir"
+    fi
+
+    if [[ -d "$sp_dir/skills" ]]; then
+        ensure_dir "$staging_dir"
+        for skill_dir in "$sp_dir/skills"/*/; do
+            [[ ! -d "$skill_dir" ]] && continue
+            local skill_name
+            skill_name=$(basename "$skill_dir")
+            local mdc_file="$staging_dir/superpowers-${skill_name}.mdc"
+
+            if [[ -f "$mdc_file" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+                # Check if content changed
+                local tmp_sp_file
+                tmp_sp_file=$(mktemp)
+                if skill_to_mdc "$skill_dir" "$tmp_sp_file"; then
+                    local existing_cksum new_cksum
+                    existing_cksum=$(file_checksum "$mdc_file")
+                    new_cksum=$(file_checksum "$tmp_sp_file")
+                    if [[ "$existing_cksum" == "$new_cksum" ]]; then
+                        rm -f "$tmp_sp_file"
+                        continue  # Content unchanged
+                    fi
+                    mv "$tmp_sp_file" "$mdc_file"
+                    log_info "Updated rule: superpowers-${skill_name}.mdc"
+                else
+                    rm -f "$tmp_sp_file"
+                fi
+            else
+                if skill_to_mdc "$skill_dir" "$mdc_file"; then
+                    log_info "Generated rule: superpowers-${skill_name}.mdc"
+                fi
+            fi
+        done
+    else
+        log_warn "Superpowers not available - skipping Superpowers rules"
+    fi
+
+    # 3. Install MCP servers (global, works for Cursor)
+    install_mcp "cursor"
+
+    log_success "Cursor installation complete!"
+    echo ""
+    log_info "Installed:"
+    log_info "  Rules (staging): $staging_dir/"
+    log_info "  MCP:             $(get_cursor_config_dir)/mcp.json"
+    echo ""
+    log_warn "IMPORTANT: Cursor only loads rules from PROJECT-LEVEL .cursor/rules/"
+    log_warn "Run './install.sh --project /path/to/project' to copy rules to a project."
+}

package/lib/install-hooks.sh

@@ -0,0 +1,285 @@
+#!/usr/bin/env bash
+# aTool - lib/install-hooks.sh
+# Hooks installation for Claude Code and Cursor
+
+set -euo pipefail
+
+# These functions are sourced by the parent script, not run directly.
+# common.sh must already be loaded.
+
+# Install hooks to a project directory
+# Args: PROJECT_DIR, IDE_TYPE (claude|cursor|kiro)
+install_hooks() {
+    local project_dir="$1"
+    local ide_type="$2"
+    local atool_root="${ATOOL_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+
+    # Kiro doesn't support hooks
+    if [[ "$ide_type" == "kiro" ]]; then
+        log_info "Kiro does not support hooks - skipping"
+        return 0
+    fi
+
+    log_step "Installing hooks for $ide_type..."
+
+    local hooks_dir
+    local hook_script_name="atool-session-start"
+
+    case "$ide_type" in
+        claude)
+            hooks_dir="$project_dir/.claude/hooks"
+            ;;
+        cursor)
+            hooks_dir="$project_dir/.cursor/hooks"
+            ;;
+        *)
+            log_warn "Unknown IDE type for hooks: $ide_type"
+            return 0
+            ;;
+    esac
+
+    ensure_dir "$hooks_dir"
+
+    # Copy lib files (required by session-start hook)
+    local project_lib_dir
+    case "$ide_type" in
+        claude) project_lib_dir="$project_dir/.claude/lib" ;;
+        cursor) project_lib_dir="$project_dir/.cursor/lib" ;;
+    esac
+    if [[ -n "${project_lib_dir:-}" ]]; then
+        ensure_dir "$project_lib_dir"
+        if [[ -f "$atool_root/lib/common.sh" ]]; then
+            run_cmd cp "$atool_root/lib/common.sh" "$project_lib_dir/common.sh"
+        fi
+        if [[ -f "$atool_root/lib/detect-stack.sh" ]]; then
+            run_cmd cp "$atool_root/lib/detect-stack.sh" "$project_lib_dir/detect-stack.sh"
+        fi
+    fi
+
+    local dest_hook="$hooks_dir/$hook_script_name"
+
+    # Check if hook already exists
+    if [[ -f "$dest_hook" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+        local existing_checksum
+        local source_checksum
+        existing_checksum=$(file_checksum "$dest_hook")
+        source_checksum=$(file_checksum "$atool_root/hooks/session-start")
+
+        if [[ "$existing_checksum" == "$source_checksum" ]]; then
+            log_info "Hook '$hook_script_name' already up to date, skipping"
+        else
+            log_info "Hook '$hook_script_name' exists but differs - backing up"
+            backup_file "$dest_hook"
+            run_cmd cp "$atool_root/hooks/session-start" "$dest_hook"
+            run_cmd chmod +x "$dest_hook"
+            log_success "Hook installed: $dest_hook"
+        fi
+    else
+        run_cmd cp "$atool_root/hooks/session-start" "$dest_hook"
+        run_cmd chmod +x "$dest_hook"
+        log_success "Hook installed: $dest_hook"
+    fi
+
+    # Install prompt-guard hook
+    local prompt_guard_src="$atool_root/hooks/prompt-guard"
+    if [[ -f "$prompt_guard_src" ]]; then
+        local prompt_guard_name="atool-prompt-guard"
+        local dest_prompt_guard="$hooks_dir/$prompt_guard_name"
+
+        if [[ -f "$dest_prompt_guard" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+            local pg_existing pg_source
+            pg_existing=$(file_checksum "$dest_prompt_guard")
+            pg_source=$(file_checksum "$prompt_guard_src")
+            if [[ "$pg_existing" == "$pg_source" ]]; then
+                log_info "Hook '$prompt_guard_name' already up to date, skipping"
+            else
+                log_info "Hook '$prompt_guard_name' exists but differs - backing up"
+                backup_file "$dest_prompt_guard"
+                run_cmd cp "$prompt_guard_src" "$dest_prompt_guard"
+                run_cmd chmod +x "$dest_prompt_guard"
+                log_success "Hook installed: $dest_prompt_guard"
+            fi
+        else
+            run_cmd cp "$prompt_guard_src" "$dest_prompt_guard"
+            run_cmd chmod +x "$dest_prompt_guard"
+            log_success "Hook installed: $dest_prompt_guard"
+        fi
+    fi
+
+    # Install doc-sync-reminder hook (PostToolUse)
+    local doc_sync_src="$atool_root/hooks/doc-sync-reminder"
+    if [[ -f "$doc_sync_src" ]]; then
+        local doc_sync_name="atool-doc-sync-reminder"
+        local dest_doc_sync="$hooks_dir/$doc_sync_name"
+
+        if [[ -f "$dest_doc_sync" ]] && [[ "${ATOOL_FORCE:-0}" != "1" ]]; then
+            local ds_existing ds_source
+            ds_existing=$(file_checksum "$dest_doc_sync")
+            ds_source=$(file_checksum "$doc_sync_src")
+            if [[ "$ds_existing" == "$ds_source" ]]; then
+                log_info "Hook '$doc_sync_name' already up to date, skipping"
+            else
+                log_info "Hook '$doc_sync_name' exists but differs - backing up"
+                backup_file "$dest_doc_sync"
+                run_cmd cp "$doc_sync_src" "$dest_doc_sync"
+                run_cmd chmod +x "$dest_doc_sync"
+                log_success "Hook installed: $dest_doc_sync"
+            fi
+        else
+            run_cmd cp "$doc_sync_src" "$dest_doc_sync"
+            run_cmd chmod +x "$dest_doc_sync"
+            log_success "Hook installed: $dest_doc_sync"
+        fi
+    fi
+
+    # Install hooks config JSON
+    local config_file
+    case "$ide_type" in
+        claude)
+            config_file="$project_dir/.claude/settings.local.json"
+            ;;
+        cursor)
+            config_file="$project_dir/.cursor/hooks.json"
+            ;;
+    esac
+
+    if [[ -n "${config_file:-}" ]]; then
+        local template_file
+        template_file="$atool_root/hooks/hooks.json"
+        [[ "$ide_type" == "cursor" ]] && template_file="$atool_root/hooks/hooks-cursor.json"
+
+        if [[ -f "$template_file" ]]; then
+            # Expand ~ paths to absolute paths for cross-platform compatibility
+            local _claude_dir _cursor_dir
+            _claude_dir=$(get_claude_config_dir)
+            _cursor_dir=$(get_cursor_config_dir)
+            local hook_abs_path
+            if [[ "$ide_type" == "claude" ]]; then
+                hook_abs_path="$_claude_dir/hooks/atool-session-start"
+            else
+                hook_abs_path="$_cursor_dir/hooks/atool-session-start"
+            fi
+            local expanded_template
+            expanded_template=$(sed "s|~/.claude/hooks/|$_claude_dir/hooks/|g; s|~/.cursor/hooks/|$_cursor_dir/hooks/|g" "$template_file")
+
+            if [[ -f "$config_file" ]]; then
+                # Merge hooks config (use temp file instead of process substitution for Windows compat)
+                local merged _tmp_template
+                _tmp_template=$(mktemp)
+                echo "$expanded_template" > "$_tmp_template"
+                merged=$(json_merge "$config_file" "$_tmp_template")
+                rm -f "$_tmp_template"
+                if ! is_dry_run; then
+                    echo "$merged" | jq '.' > "$config_file"
+                else
+                    log_info "[DRY-RUN] Would merge hooks config into $config_file"
+                fi
+            else
+                if ! is_dry_run; then
+                    echo "$expanded_template" | jq '.' > "$config_file"
+                else
+                    log_info "[DRY-RUN] Would write hooks config to $config_file"
+                fi
+            fi
+            log_success "Hooks config updated: $config_file"
+        fi
+    fi
+}
+
+# Install hooks globally (for non-project-specific installation)
+# Args: IDE_TYPE
+install_hooks_global() {
+    local ide_type="$1"
+    local atool_root="${ATOOL_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+
+    case "$ide_type" in
+        claude)
+            # 1. Copy lib files (required by session-start hook)
+            local claude_config_dir
+            claude_config_dir=$(get_claude_config_dir)
+            local claude_lib_dir="$claude_config_dir/lib"
+            ensure_dir "$claude_lib_dir"
+            if [[ -f "$atool_root/lib/common.sh" ]]; then
+                run_cmd cp "$atool_root/lib/common.sh" "$claude_lib_dir/common.sh"
+            fi
+            if [[ -f "$atool_root/lib/detect-stack.sh" ]]; then
+                run_cmd cp "$atool_root/lib/detect-stack.sh" "$claude_lib_dir/detect-stack.sh"
+            fi
+
+            # 2. Copy hook scripts
+            local claude_hooks_dir="$claude_config_dir/hooks"
+            ensure_dir "$claude_hooks_dir"
+            run_cmd cp "$atool_root/hooks/session-start" "$claude_hooks_dir/atool-session-start"
+            run_cmd chmod +x "$claude_hooks_dir/atool-session-start"
+
+            # Copy prompt-guard hook
+            if [[ -f "$atool_root/hooks/prompt-guard" ]]; then
+                run_cmd cp "$atool_root/hooks/prompt-guard" "$claude_hooks_dir/atool-prompt-guard"
+                run_cmd chmod +x "$claude_hooks_dir/atool-prompt-guard"
+            fi
+
+            # Copy doc-sync-reminder hook (PostToolUse)
+            if [[ -f "$atool_root/hooks/doc-sync-reminder" ]]; then
+                run_cmd cp "$atool_root/hooks/doc-sync-reminder" "$claude_hooks_dir/atool-doc-sync-reminder"
+                run_cmd chmod +x "$claude_hooks_dir/atool-doc-sync-reminder"
+            fi
+
+            # 2. Register hooks config in settings.json
+            #    Claude Code reads hooks from settings.json, NOT from files on disk
+            local settings_file="$claude_config_dir/settings.json"
+            local hooks_template="$atool_root/hooks/hooks.json"
+
+            if [[ -f "$hooks_template" ]]; then
+                # Expand ~ paths to absolute paths for cross-platform compatibility
+                local _claude_dir _cursor_dir
+                _claude_dir=$(get_claude_config_dir)
+                _cursor_dir=$(get_cursor_config_dir)
+                local expanded_template
+                expanded_template=$(sed "s|~/.claude/hooks/|$_claude_dir/hooks/|g; s|~/.cursor/hooks/|$_cursor_dir/hooks/|g" "$hooks_template")
+
+                if [[ -f "$settings_file" ]]; then
+                    # Check both SessionStart and UserPromptSubmit and PostToolUse
+                    local existing_ss existing_ups existing_ptu
+                    existing_ss=$(jq -r '.hooks.SessionStart[]?.hooks[]?.command // empty' "$settings_file" 2>/dev/null | grep -c "atool-session-start" 2>/dev/null || true)
+                    existing_ups=$(jq -r '.hooks.UserPromptSubmit[]?.hooks[]?.command // empty' "$settings_file" 2>/dev/null | grep -c "atool-prompt-guard" 2>/dev/null || true)
+                    existing_ptu=$(jq -r '.hooks.PostToolUse[]?.hooks[]?.command // empty' "$settings_file" 2>/dev/null | grep -c "atool-doc-sync-reminder" 2>/dev/null || true)
+                    existing_ss="${existing_ss:-0}"
+                    existing_ups="${existing_ups:-0}"
+                    existing_ptu="${existing_ptu:-0}"
+                    if [[ "$existing_ss" -gt 0 ]] && [[ "$existing_ups" -gt 0 ]] && [[ "$existing_ptu" -gt 0 ]]; then
+                        log_info "Claude global hooks already registered in settings.json, skipping"
+                    else
+                        local merged _tmp_tpl
+                        _tmp_tpl=$(mktemp)
+                        echo "$expanded_template" > "$_tmp_tpl"
+                        merged=$(json_merge "$settings_file" "$_tmp_tpl")
+                        rm -f "$_tmp_tpl"
+                        backup_file "$settings_file"
+                        if ! is_dry_run; then
+                            echo "$merged" | jq '.' > "$settings_file"
+                        fi
+                        log_success "Claude hooks registered in $settings_file"
+                    fi
+                else
+                    if ! is_dry_run; then
+                        echo "$expanded_template" | jq '.' > "$settings_file"
+                    else
+                        log_info "[DRY-RUN] Would write hooks config to $settings_file"
+                    fi
+                    log_success "Claude hooks registered in $settings_file"
+                fi
+            fi
+
+            log_success "Global Claude hook installed"
+            ;;
+        cursor)
+            # Cursor does not support global hooks that run on session start
+            # Cursor only supports project-level .cursor/rules/*.mdc for AI rules
+            log_info "Cursor does not support global session hooks"
+            log_info "Cursor rules are applied per-project via .cursor/rules/*.mdc"
+            ;;
+        *)
+            log_info "$ide_type does not support global hooks"
+            ;;
+    esac
+}