appiq-solution 1.4.8 → 1.4.9

package/SuperClaude/RULES.md

@@ -1,220 +0,0 @@
-# RULES.md - Ops Rules & Standards
-
-## Legend
-| Symbol | Meaning | | Abbrev | Meaning |
-|--------|---------|---|--------|---------|
-| → | leads to | | ops | operations |
-| > | greater than | | cfg | configuration |
-| & | and/with | | std | standard |
-| C | critical | | H | high |
-| M | medium | | L | low |
-
-> Govern → Enforce → Guide
-
-## 1. Core Protocols
-
-### Critical Thinking [H:8]
-```yaml
-Evaluate: CRIT[10]→Block | HIGH[8-9]→Warn | MED[5-7]→Advise
-Git: Uncommitted→"Commit?" | Wrong branch→"Feature?" | No backup→"Save?"
-Efficiency: Question→Think | Suggest→Action | Explain→2-3 lines | Iterate>Analyze
-Feedback: Point out flaws | Suggest alternatives | Challenge assumptions
-Avoid: Excessive agreement | Unnecessary praise | Blind acceptance
-Approach: "Consider X instead" | "Risk: Y" | "Alternative: Z"
-```
-
-### Evidence-Based [C:10]
-```yaml
-Prohibited: best|optimal|faster|secure|better|improved|enhanced|always|never|guaranteed
-Required: may|could|potentially|typically|often|sometimes
-Evidence: testing confirms|metrics show|benchmarks prove|data indicates
-```
-
-### Thinking Modes
-```yaml
-Triggers: Natural language OR flags (--think|--think-hard|--ultrathink)
-none: 1file <10lines | think: Multi-file 4K | hard: Architecture 10K | ultra: Critical 32K
-Usage: /user:analyze --think | "think about X" | /user:design --ultrathink
-```
-
-## 2. Severity System
-
-### CRITICAL [10] → Block
-```yaml
-Security: NEVER commit secrets|execute untrusted|expose PII
-Ops: NEVER force push shared|delete no backup|skip validation
-Dev: ALWAYS validate input|parameterized queries|hash passwords
-Research: NEVER impl w/o docs|ALWAYS WebSearch/C7→unfamiliar libs|ALWAYS verify patterns w/ official docs
-Docs: ALWAYS Claude reports→.claudedocs/|project docs→/docs|NEVER mix ops w/ project docs
-```
-
-### HIGH [7-9] → Fix Required
-```yaml
-[9] Security|Production: Best practices|No debug in prod|Evidence-based
-[8] Quality|Performance: Error handling|N+1 prevention|Test coverage|SOLID
-[7] Standards|Efficiency: Caching|Git workflow|Task mgmt|Context mgmt
-```
-
-### MEDIUM [4-6] → Warn
-```yaml
-[6] DRY|Module boundaries|Complex docs
-[5] Naming|SOLID|Examples|Doc structure
-[4] Formatting|Tech terms|Organization
-```
-
-### LOW [1-3] → Suggest
-```yaml
-[3] Changelog|Algorithms [2] Doc examples [1] Modern syntax
-```
-
-## 3. Ops Standards
-
-### Files & Code
-```yaml
-Rules: Read→Write | Edit>Write | No docs unless asked | Atomic ops
-Code: Clean|Conventions|Error handling|No duplication|NO COMMENTS
-```
-
-### Tasks [H:7]
-```yaml
-TodoWrite: 3+ steps|Multiple requests | TodoRead: Start|Frequent
-Rules: One in_progress|Update immediate|Track blockers
-Integration: /user:scan --validate→execute | Risky→checkpoint | Failed→rollback
-```
-
-### Tools & MCP
-```yaml
-Native: Appropriate tool|Batch|Validate|Handle failures|Native>MCP(simple)
-MCP: C7→Docs | Seq→Complex | Pup→Browser | Magic→UI | Monitor tokens
-```
-
-### Performance [H:8]
-```yaml
-Parallel: Unrelated files|Independent|Multiple sources
-Efficiency: Min tokens|Cache|Skip redundant|Batch similar
-```
-
-### Git [H:8]
-```yaml
-Before: status→branch→fetch→pull --rebase | Commit: status→diff→add -p→commit | Small|Descriptive|Test first
-Checkpoint: shared/checkpoint.yml | Auto before risky | /rollback
-```
-
-### Communication [H:8]
-```yaml
-Mode: 🎭Persona|🔧Command|✅Complete|🔄Switch | Style: Concise|Structured|Evidence-based|Actionable
-Code output: Minimal comments | Concise names | No explanatory text
-Responses: Consistent format | Done→Issues→Next | Remember context
-```
-
-### Constructive Pushback [H:8]
-```yaml
-When: Inefficient approach | Security risk | Over-engineering | Bad practice
-How: Direct>subtle | Alternative>criticism | Evidence>opinion
-Ex: "Simpler: X" | "Risk: SQL injection" | "Consider: existing lib"
-Never: Personal attacks | Condescension | Absolute rejection
-```
-
-### Efficiency [C:9]
-```yaml
-Speed: Simple→Direct | Stuck→Pivot | Focus→Impact | Iterate>Analyze
-Output: Minimal→first | Expand→if asked | Actionable>theory
-Keywords: "quick"→Skip | "rough"→Minimal | "urgent"→Direct | "just"→Min scope
-Actions: Do>explain | Assume obvious | Skip permissions | Remember session
-```
-
-### Error Recovery [H:9]
-```yaml
-On failure: Try alternative → Explain clearly → Suggest next step
-Ex: Command fails→Try variant | File not found→Search nearby | Permission→Suggest fix
-Never: Give up silently | Vague errors | Pattern: What failed→Why→Alternative→User action
-```
-
-### Session Awareness [H:9]
-```yaml
-Track: Recent edits | User corrections | Found paths | Key facts
-Remember: "File is in X"→Use X | "I prefer Y"→Do Y | Edited file→It's changed
-Never: Re-read unchanged | Re-check versions | Ignore corrections
-Cache: Package versions | File locations | User preferences | cfg values
-Learn: Code style preferences | Testing framework choices | File org patterns
-Adapt: Default→learned preferences | Mention when using user's style
-Pattern Detection: analyze→fix→test 3+ times → "Automate workflow?"
-Sequences: build→test→deploy | scan→fix→verify | review→refactor→test
-Offer: "Notice X→Y→Z. Create shortcut?" | Remember if declined
-```
-
-### Action & Command Efficiency [H:8]
-```yaml
-Just do: Read→Edit→Test | No "I will now..." | No "Should I?"
-Skip: Permission for obvious | Explanations before action | Ceremonial text
-Assume: Error→Fix | Warning→Address | Found issue→Resolve
-Reuse: Previous results | Avoid re-analysis | Chain outputs
-Smart defaults: Last paths | Found issues | User preferences
-Workflows: analyze→fix→test | build→test→deploy | scan→patch
-Batch: Similar fixes together | Related files parallel | Group by type
-```
-
-### Smart Defaults & Handling [H:8-9]
-```yaml
-File Discovery: Recent edits | Common locations | Git status | Project patterns
-Commands: "test"→package.json scripts | "build"→project cfg | "start"→main entry
-Context Clues: Recent mentions | Error messages | Modified files | Project type
-Interruption: "stop"|"wait"|"pause"→Immediate ack | State: Save progress | Clean partial ops
-Solution: Simple→Moderate→Complex | Try obvious first | Escalate if needed
-```
-
-### Project Quality [H:7-8]
-```yaml
-Opportunistic: Notice improvements | Mention w/o fixing | "Also spotted: X"
-Cleanliness: Remove cruft while working | Clean after ops | Suggest cleanup
-Standards: No debug code in commits | Clean build artifacts | Updated deps
-Balance: Primary task first | Secondary observations last | Don't overwhelm
-```
-
-## 4. Security Standards [C:10]
-
-```yaml
-Sandboxing: Project dir|localhost|Doc APIs ✓ | System|~/.ssh|AWS ✗ | Timeout|Memory|Storage limits
-Validation: Absolute paths|No ../.. | Whitelist cmds|Escape args
-Detection: /api[_-]?key|token|secret/i → Block | PII→Refuse | Mask logs
-Audit: Delete|Overwrite|Push|Deploy → .claude/audit/YYYY-MM-DD.log
-Levels: READ→WRITE→EXECUTE→ADMIN | Start low→Request→Temp→Revoke
-Emergency: Stop→Alert→Log→Checkpoint→Fix
-```
-
-## 5. Ambiguity Resolution [H:7]
-
-```yaml
-Keywords: "something like"|"maybe"|"fix it"|"etc" | Missing: No paths|Vague scope|No criteria
-Strategies: Options: "A)[interpretation] B)[alternative] Which?" | Refine: Broad→Category→Specific→Confirm
-Context: Recent ops|Files → "You mean [X]?" | Common: "Fix bug"→Which? | "Better"→How?
-Risk: HIGH→More Qs | LOW→Safe defaults | Flow: Detect→CRIT block|HIGH options|MED suggest|LOW proceed
-```
-
-## 6. Dev Practices
-
-```yaml
-Design: KISS[H:7]: Simple>clever | YAGNI[M:6]: Immediate only | SOLID[H:8]: Single resp|Open/closed
-DRY[M:6]: Extract common|cfg>duplicate | Clean Code[C:9]: <20lines|<5cyclo|<3nest
-Code Gen[C:10]: NO comments unless asked | Short>long names | Minimal boilerplate
-Docs[C:9]: Bullets>paragraphs | Essential only | No "Overview"|"Introduction"
-UltraCompressed[C:10]: --uc flag | Context>70% | ~70% reduction | Legend REQUIRED
-Architecture[H:8]: DDD: Bounded contexts|Aggregates|Events | Event→Pub/Sub | Microservices→APIs
-Testing[H:8]: TDD cycle|AAA pattern|Unit>Integration>E2E | Test all|Mock deps|Edge cases
-Performance[H:7]: Measure→Profile→Optimize | Cache smart|Async I/O | Avoid: Premature opt|N+1
-```
-
-## 7. Efficiency & Mgmt
-
-```yaml
-Context[C:9]: >60%→/compact | >90%→Force | Keep decisions|Remove redundant
-Tokens[C:10]: Symbols>words|YAML>prose|Bullets>paragraphs | Remove the|that|which
-Cost[H:8]: Simple→sonnet$ | Complex→sonnet4$$ | Critical→opus4$$$ | Response<4lines
-Advanced: Orchestration[H:7]: Parallel|Shared context | Iterative[H:8]: Boomerang|Measure|Refine
-Root Cause[H:7]: Five whys|Document|Prevent | Memory[M:6]: Store decisions|Share context
-Automation[H:7-8]: Validate env|Error handling|Timeouts | CI/CD: Idempotent|Retry|Secure creds
-Integration: Security: shared/*.yml | Ambiguity: analyzer→clarify | shared/impl.yml
-```
-
----
-*SuperClaude v4.0.0 | C=CRITICAL H=HIGH M=MEDIUM | Optimized ops rules*

package/SuperClaude/SECURITY.md

@@ -1,91 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported |
-|---------|-----------|
-| 4.0.x   | ✅ Yes    |
-| < 4.0   | ❌ No     |
-
-## Reporting Security Vulnerabilities
-
-We take security seriously. If you discover a security vulnerability, please follow these steps:
-
-### 🔒 Private Reporting (Preferred)
-
-1. **Do NOT** create a public issue
-2. Email security details to: anton.knoery@gmail.com
-3. Include "SuperClaude Security" in subject line
-4. Provide detailed description of the vulnerability
-
-### 📝 Required Information
-
-Please include:
-- Description of the vulnerability
-- Steps to reproduce the issue
-- Potential impact assessment
-- Any suggested fixes or mitigations
-- Your contact information for follow-up
-
-### ⏱️ Response Timeline
-
-- **24 hours**: Initial acknowledgment
-- **72 hours**: Preliminary assessment
-- **7 days**: Detailed response with next steps
-- **30 days**: Resolution target (depending on complexity)
-
-## Security Considerations
-
-### Configuration Framework Security
-- SuperClaude is a configuration framework, not executable software
-- No network connections or data transmission
-- Files are stored locally in ~/.claude/
-- Shell scripts have limited system access
-
-### Installation Security
-- install.sh performs file operations only
-- No sudo/admin privileges required
-- Backup existing configurations before installation
-- All operations within user home directory
-
-### Usage Security
-- Configuration files are read-only for Claude Code
-- No sensitive data stored in configurations
-- Slash commands execute through Claude Code's security model
-- MCP integrations follow Claude Code's sandbox restrictions
-
-## Best Practices
-
-### For Users
-- Review install.sh before execution
-- Keep SuperClaude updated
-- Report suspicious behavior
-- Use official installation methods only
-
-### For Contributors
-- Follow secure coding practices
-- No hardcoded secrets or credentials
-- Validate all user inputs
-- Test security implications of changes
-
-## Scope
-
-This security policy covers:
-- SuperClaude configuration files
-- Installation scripts
-- GitHub repository security
-- Community interaction security
-
-## Disclaimer
-
-SuperClaude is provided "as is" without warranty. While we strive for security, users are responsible for:
-- Reviewing code before installation
-- Using in appropriate environments
-- Following Claude Code security guidelines
-- Backing up existing configurations
-
----
-
-**Questions?** Contact anton.knoery@gmail.com
-
-*SuperClaude v4.0.0 | Security-conscious configuration framework*

package/SuperClaude/install.sh

@@ -1,296 +0,0 @@
-#!/bin/bash
-
-# SuperClaude Installer Script
-# Installs SuperClaude configuration framework to enhance Claude Code
-
-set -e  # Exit on error
-
-# Colors for output
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-# Default installation directory
-INSTALL_DIR="$HOME/.claude"
-FORCE_INSTALL=false
-UPDATE_MODE=false
-UNINSTALL_MODE=false
-
-# Function to show usage
-show_usage() {
-    echo "Usage: $0 [OPTIONS]"
-    echo ""
-    echo "Options:"
-    echo "  --dir <directory>    Install to custom directory (default: $HOME/.claude)"
-    echo "  --force              Skip confirmation prompts (for automation)"
-    echo "  --update             Update existing installation (preserves customizations)"
-    echo "  --uninstall          Remove SuperClaude from specified directory"
-    echo "  -h, --help          Show this help message"
-    echo ""
-    echo "Examples:"
-    echo "  $0                          # Install to default location"
-    echo "  $0 --dir /opt/claude        # Install to /opt/claude"
-    echo "  $0 --dir ./local-claude     # Install to ./local-claude"
-    echo "  $0 --force                  # Install without prompts"
-    echo "  $0 --update                 # Update existing installation"
-    echo "  $0 --uninstall              # Remove SuperClaude"
-}
-
-# Parse command line arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --dir)
-            INSTALL_DIR="$2"
-            shift 2
-            ;;
-        --force)
-            FORCE_INSTALL=true
-            shift
-            ;;
-        --update)
-            UPDATE_MODE=true
-            shift
-            ;;
-        --uninstall)
-            UNINSTALL_MODE=true
-            shift
-            ;;
-        -h|--help)
-            show_usage
-            exit 0
-            ;;
-        *)
-            echo -e "${RED}Error: Unknown option $1${NC}"
-            show_usage
-            exit 1
-            ;;
-    esac
-done
-
-# Convert to absolute path if relative
-if [[ ! "$INSTALL_DIR" = /* ]]; then
-    # Check if parent directory exists
-    parent_dir=$(dirname "$INSTALL_DIR")
-    if [[ ! -d "$parent_dir" ]]; then
-        echo -e "${RED}Error: Parent directory '$parent_dir' does not exist${NC}"
-        exit 1
-    fi
-    INSTALL_DIR="$(cd "$parent_dir" && pwd)/$(basename "$INSTALL_DIR")"
-fi
-
-# Handle uninstall mode
-if [[ "$UNINSTALL_MODE" = true ]]; then
-    echo -e "${GREEN}SuperClaude Uninstaller${NC}"
-    echo "========================"
-    echo -e "Target directory: ${YELLOW}$INSTALL_DIR${NC}"
-    echo ""
-    
-    if [[ ! -d "$INSTALL_DIR" ]]; then
-        echo -e "${RED}Error: SuperClaude not found at $INSTALL_DIR${NC}"
-        exit 1
-    fi
-    
-    if [[ "$FORCE_INSTALL" != true ]]; then
-        echo -e "${YELLOW}This will remove SuperClaude from $INSTALL_DIR${NC}"
-        echo -n "Are you sure you want to continue? (y/n): "
-        read -r confirm_uninstall
-        if [ "$confirm_uninstall" != "y" ]; then
-            echo "Uninstall cancelled."
-            exit 0
-        fi
-    fi
-    
-    echo "Removing SuperClaude..."
-    rm -rf "$INSTALL_DIR"
-    echo -e "${GREEN}✓ SuperClaude uninstalled successfully!${NC}"
-    exit 0
-fi
-
-echo -e "${GREEN}SuperClaude Installer${NC}"
-echo "======================"
-echo -e "Installation directory: ${YELLOW}$INSTALL_DIR${NC}"
-echo ""
-
-# Check write permissions
-parent_for_write=$(dirname "$INSTALL_DIR")
-if [[ -d "$INSTALL_DIR" ]]; then
-    # Directory exists, check if we can write to it
-    if [[ ! -w "$INSTALL_DIR" ]]; then
-        echo -e "${RED}Error: No write permission for $INSTALL_DIR${NC}"
-        exit 1
-    fi
-elif [[ ! -w "$parent_for_write" ]]; then
-    # Directory doesn't exist, check if we can create it
-    echo -e "${RED}Error: No write permission to create $INSTALL_DIR${NC}"
-    exit 1
-fi
-
-# Confirmation prompt (skip if --force)
-if [[ "$FORCE_INSTALL" != true ]]; then
-    if [[ "$UPDATE_MODE" = true ]]; then
-        echo -e "${YELLOW}This will update SuperClaude in $INSTALL_DIR${NC}"
-    else
-        echo -e "${YELLOW}This will install SuperClaude in $INSTALL_DIR${NC}"
-    fi
-    echo -n "Are you sure you want to continue? (y/n): "
-    read -r confirm_install
-    if [ "$confirm_install" != "y" ]; then
-        echo "Installation cancelled."
-        exit 0
-    fi
-fi
-echo ""
-
-# Check if we're in SuperClaude directory
-if [ ! -f "CLAUDE.md" ] || [ ! -d ".claude/commands" ]; then
-    echo -e "${RED}Error: This script must be run from the SuperClaude directory${NC}"
-    echo ""
-    echo "Expected files not found. Please ensure you are in the root SuperClaude directory."
-    echo "Missing: $([ ! -f "CLAUDE.md" ] && echo "CLAUDE.md ")$([ ! -d ".claude/commands" ] && echo ".claude/commands/")"
-    echo ""
-    echo "Solution: cd to the SuperClaude directory and run: ./install.sh"
-    exit 1
-fi
-
-# Check if existing directory exists and has files
-if [ -d "$INSTALL_DIR" ] && [ "$(ls -A "$INSTALL_DIR" 2>/dev/null)" ]; then
-    echo -e "${YELLOW}Existing configuration found at $INSTALL_DIR${NC}"
-    
-    # In update mode, always backup
-    if [[ "$UPDATE_MODE" = true ]] || [[ "$FORCE_INSTALL" = true ]]; then
-        backup_choice="y"
-    else
-        echo -n "Backup existing configuration? (y/n): "
-        read -r backup_choice
-    fi
-    
-    if [ "$backup_choice" = "y" ]; then
-        # Create backup directory in parent directory to avoid conflicts
-        backup_dir="$(dirname "$INSTALL_DIR")/superclaude-backup.$(date +%Y%m%d_%H%M%S)"
-        mkdir -p "$backup_dir"
-        
-        # Backup ALL existing files
-        echo "Backing up all existing files..."
-        
-        # Copy everything except backup directories
-        for item in "$INSTALL_DIR"/*; do
-            basename_item=$(basename "$item")
-            # Skip backup directories to avoid nested backups
-            if [[ ! "$basename_item" =~ ^backup\. ]]; then
-                if [ -e "$item" ]; then
-                    cp -r "$item" "$backup_dir/"
-                fi
-            fi
-        done
-        
-        echo -e "${GREEN}Backed up existing files to: $backup_dir${NC}"
-    fi
-elif [ -d "$INSTALL_DIR" ]; then
-    echo -e "${YELLOW}Directory $INSTALL_DIR exists but is empty${NC}"
-fi
-
-echo ""
-if [[ "$UPDATE_MODE" = true ]]; then
-    echo "Updating SuperClaude..."
-else
-    echo "Installing SuperClaude..."
-fi
-
-# Create directory structure
-echo "Creating directories..."
-mkdir -p "$INSTALL_DIR/commands/shared"
-
-# Copy main configuration files
-echo "Copying configuration files..."
-if [[ "$UPDATE_MODE" = true ]]; then
-    # In update mode, preserve user modifications
-    for file in CLAUDE.md RULES.md PERSONAS.md MCP.md; do
-        if [[ -f "$INSTALL_DIR/$file" ]]; then
-            # Check if file differs from source
-            if ! cmp -s "$file" "$INSTALL_DIR/$file"; then
-                echo "  Preserving customized $file (new version: $file.new)"
-                cp "$file" "$INSTALL_DIR/$file.new"
-            else
-                cp "$file" "$INSTALL_DIR/"
-            fi
-        else
-            cp "$file" "$INSTALL_DIR/"
-        fi
-    done
-else
-    cp CLAUDE.md RULES.md PERSONAS.md MCP.md "$INSTALL_DIR/"
-fi
-
-# Copy command files
-echo "Copying slash commands..."
-cp .claude/commands/*.md "$INSTALL_DIR/commands/" 2>/dev/null || true
-
-# Copy shared resources
-echo "Copying shared resources..."
-cp .claude/commands/shared/*.yml "$INSTALL_DIR/commands/shared/"
-
-# Verify installation
-echo ""
-echo "Verifying installation..."
-
-# Count installed files
-main_files=$(ls -1 "$INSTALL_DIR/"*.md 2>/dev/null | wc -l)
-command_files=$(ls -1 "$INSTALL_DIR/commands/"*.md 2>/dev/null | wc -l)
-shared_files=$(ls -1 "$INSTALL_DIR/commands/shared/"*.yml 2>/dev/null | wc -l)
-
-echo -e "Main config files: ${GREEN}$main_files${NC} (expected: 4)"
-echo -e "Command files: ${GREEN}$command_files${NC} (expected: 19)"
-echo -e "Shared resources: ${GREEN}$shared_files${NC} (expected: 31)"
-
-# Check if installation was successful
-if [ "$main_files" -ge 4 ] && [ "$command_files" -ge 19 ] && [ "$shared_files" -ge 31 ]; then
-    echo ""
-    if [[ "$UPDATE_MODE" = true ]]; then
-        echo -e "${GREEN}✓ SuperClaude updated successfully!${NC}"
-        echo ""
-        # Check for .new files
-        new_files=$(find "$INSTALL_DIR" -name "*.new" 2>/dev/null)
-        if [[ -n "$new_files" ]]; then
-            echo -e "${YELLOW}Note: The following files have updates available:${NC}"
-            echo "$new_files" | while read -r file; do
-                echo "  - $file"
-            done
-            echo ""
-            echo "To review changes: diff <file> <file>.new"
-            echo "To apply update: mv <file>.new <file>"
-            echo ""
-        fi
-    else
-        echo -e "${GREEN}✓ SuperClaude installed successfully!${NC}"
-        echo ""
-        echo "Next steps:"
-        echo "1. Open any project with Claude Code"
-        echo "2. Try a command: /user:analyze --code"
-        echo "3. Activate a persona: /persona:architect"
-        echo ""
-    fi
-    if [ -n "$backup_dir" ] && [ -d "$backup_dir" ]; then
-        echo -e "${YELLOW}Note: Your previous configuration was backed up to:${NC}"
-        echo "$backup_dir"
-        echo ""
-    fi
-    echo "For more information, see README.md"
-else
-    echo ""
-    echo -e "${RED}✗ Installation may be incomplete${NC}"
-    echo ""
-    echo "Expected vs Actual file counts:"
-    echo "  Main config files: $main_files/4$([ "$main_files" -lt 4 ] && echo " ❌" || echo " ✓")"
-    echo "  Command files: $command_files/19$([ "$command_files" -lt 19 ] && echo " ❌" || echo " ✓")"
-    echo "  Shared resources: $shared_files/31$([ "$shared_files" -lt 31 ] && echo " ❌" || echo " ✓")"
-    echo ""
-    echo "Troubleshooting steps:"
-    echo "1. Check for error messages above"
-    echo "2. Ensure you have write permissions to $INSTALL_DIR"
-    echo "3. Verify all source files exist in the current directory"
-    echo "4. Try running with sudo if permission errors occur"
-    echo ""
-    echo "For manual installation, see README.md"
-    exit 1
-fi