docs: add comprehensive blog post about the dotfiles system

Create detailed blog post covering the intelligent dotfiles management
system, following the structured guide from BLOG_POST_GUIDE.md.

Content includes:
- Problem statement and solution overview
- Technical deep dive into profile detection
- Command interface examples and usage
- Performance metrics and real-world benefits
- Architecture principles and lessons learned
- Getting started guide and future roadmap

Target audience: Developers, DevOps engineers, system administrators
Estimated reading time: 12-15 minutes

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

BLOG_POST.md

@@ -0,0 +1,358 @@
+# I Built an AI-Powered Dotfiles System That Adapts to Any Machine
+
+Picture this: You SSH into a new server, and within 30 seconds, you have your complete terminal environment—but only the tools you actually need. No Claude AI on production servers, no Docker on lightweight VMs, but your favorite aliases and shortcuts everywhere. This is the power of intelligent dotfiles management.
+
+After years of frustration with inconsistent development environments and bloated configurations, I built a dotfiles system that thinks. It auto-detects machine types, installs appropriate packages, and keeps everything in sync—without the usual mess of manual configuration.
+
+## The Multi-Machine Problem
+
+If you're managing multiple machines, you've probably faced these challenges:
+
+### The Different Tools Dilemma
+- **Production servers** shouldn't have development bloat (Docker, AI tools, etc.)
+- **Development machines** need the full toolchain (editors, AI assistants, containers)
+- **Personal laptops** want convenience tools (task managers, multimedia utilities)
+- **Lightweight VMs** need minimal footprints
+
+### The Update Nightmare
+```bash
+# Traditional approach
+$ npm update -g
+# 30-60 seconds later...
+# Everything updated, even things that didn't need it
+```
+
+### The Consistency Challenge
+You want the same shortcuts everywhere, but different capabilities per machine. Most dotfiles solutions give you everything everywhere, or require complex manual configuration.
+
+## The Intelligent Solution
+
+I designed a system around three core innovations:
+
+### 1. Machine Profile Auto-Detection
+
+The system automatically scores different environmental indicators:
+
+```bash
+Server Indicators:
+├── systemd active (30 points)
+├── SSH connection (25 points)  
+├── Multi-user target (20 points)
+└── No logged users (10 points)
+
+Development Indicators:
+├── Dev tools present (30 points)
+├── Code editor available (25 points)
+├── Dev directories exist (20 points)
+└── GUI environment (15 points)
+
+Personal Indicators:
+├── Personal directories (20 points)
+├── Browser available (25 points)
+└── Personal home path (15 points)
+```
+
+The highest score determines the machine profile, which then drives package selection.
+
+### 2. Profile-Aware Package Management
+
+Instead of installing everything everywhere:
+
+```bash
+# Server profile gets:
+curl, git, vim, sshuttle, ripgrep, fd
+
+# Dev profile adds:
+claude-code, gemini-cli, fzf, bat, delta, docker
+
+# Personal profile adds:
+task-master, all convenience tools
+```
+
+### 3. Smart Update System
+
+```bash
+# Traditional approach
+npm update -g                    # 30-60 seconds, updates everything
+
+# Smart approach  
+dot packages check-updates       # 2-5 seconds, fast version checking
+dot packages update              # 10-20 seconds, only outdated packages
+```
+
+## The Installation Experience
+
+The setup process is designed to be effortless:
+
+```bash
+$ curl -fsSL https://git.turnersrus.com/razzam21/dotfiles/-/raw/dev/install-web.sh | bash
+
+🤖 Machine Profile Detection
+==============================
+Detected profile: dev
+
+Available profiles:
+  server    - Minimal server setup
+  dev       - Full development setup  
+  dev-lite  - Development without heavy packages
+  personal  - Personal machine (all tools)
+  minimal   - Bare bones
+
+Use detected profile 'dev'? [Y/n]: Y
+✅ Profile set to: dev
+
+📦 Checking system packages...
+  ✅ curl already installed
+  Installing git...
+  ✅ git installed successfully
+
+⚡ Checking binary packages...
+  Installing claude-code...
+  ✅ claude-code installed successfully
+  
+🎉 Dotfiles installation complete!
+```
+
+## Modern Command Interface
+
+The system uses an intuitive `dot <action> [subaction] [flags]` structure:
+
+```bash
+# Sync Management
+dot sync                    # Manual sync now
+dot sync --force            # Force sync (ignore timing limits)
+dot sync status             # Show sync status and last update
+dot sync on                 # Enable automatic syncing
+dot sync off                # Disable automatic syncing
+
+# Package Management
+dot packages                # Show package status for current profile
+dot packages install        # Install all packages for current profile
+dot packages check          # Check package installation status
+dot packages update         # Install pending updates
+dot packages check-updates  # Check for package updates (fast)
+
+# Profile Management
+dot profile                 # Show current machine profile
+dot profile set <name>      # Switch to specified profile
+dot profile detect          # Re-detect machine type
+
+# Reset and Cleanup
+dot reset                   # Interactive reset menu
+dot reset --soft            # Remove configs, restore originals
+dot reset --hard            # Soft reset + uninstall packages
+dot reset --nuclear         # Complete removal (back to vanilla)
+```
+
+## Daily Usage Examples
+
+### Fast Update Checking
+```bash
+$ dot packages check-updates
+🔍 Checking npm packages for updates...
+  📦 @anthropic-ai/claude-code: 2.1.0 → 2.2.0
+  ✅ @google/gemini-cli: 1.5.2 (latest)
+
+💡 Updates available! Run 'dot packages update' to install them.
+
+$ dot packages update
+🔄 Updating packages...
+  Updating: @anthropic-ai/claude-code
+  ✅ Updated npm packages
+🎉 Package updates completed!
+```
+
+### Profile Switching
+```bash
+# Moving to a new machine type
+$ dot profile set server
+✅ Profile set to: server
+🔄 Run 'dot packages install' to apply profile changes
+
+$ dot packages install
+📦 Checking system packages for profile: server
+  ✅ curl already installed
+  ✅ git already installed  
+  ✅ vim already installed
+  Installing sshuttle...
+  ✅ sshuttle installed successfully
+
+⚡ Skipping development packages (server profile)
+🎉 Package check completed!
+```
+
+## Real-World Benefits
+
+### Performance Metrics
+
+```bash
+Terminal Startup Time:
+├── Cold start (with sync): ~2 seconds
+├── Warm start: ~0.1 seconds  
+└── Background operations: Non-blocking
+
+Update Efficiency:
+├── Traditional: npm update -g (30-60 seconds)
+├── Smart check: dot packages check-updates (2-5 seconds)
+└── Selective update: dot packages update (10-20 seconds)
+
+Resource Usage:
+├── Memory: Minimal (shell functions only)
+├── Disk: ~50MB for full dev profile
+└── Network: Efficient API calls, cached results
+```
+
+### Before/After Comparison
+
+**Before (Traditional Dotfiles):**
+- Same heavy config on every machine
+- Production server running Docker & development tools
+- 5-minute setup time per machine
+- Manual package management
+- Inconsistent environments
+- No easy way to reset/clean
+
+**After (Smart Dotfiles):**
+- Adaptive configuration per machine type
+- Server gets only essential tools
+- 30-second setup with auto-detection
+- Automatic package management & updates
+- Consistent shortcuts, appropriate tools
+- One-command reset to vanilla
+
+## Advanced Features
+
+### Safety-First Reset System
+```bash
+$ dot reset
+Choose reset level:
+1) Soft Reset   - Remove symlinks, restore original configs
+2) Hard Reset   - Soft + uninstall packages  
+3) Nuclear Reset - Hard + remove dotfiles directory
+4) Backup Only  - Create backup without changes
+
+# Always creates backup before any changes
+📦 Creating backup of current dotfiles...
+✅ Backup created at: /home/user/dotfiles_backup_20250115_143022
+```
+
+### Universal Command Interface
+```bash
+# These work on ALL machines, regardless of profile:
+g                    # git
+ga                   # git add  
+gs                   # git status
+..                   # cd ..
+l                    # ls -lah
+ports                # netstat -tuln
+myip                 # curl ifconfig.me
+
+# Profile-specific commands only available where appropriate:
+claude               # Only on dev/personal machines
+tm                   # task-master, only on personal machines
+```
+
+## Technical Architecture
+
+The system is built around several key principles:
+
+### Design Principles
+1. **Adaptive over Universal**: Different machines have different needs
+2. **Fast over Comprehensive**: Quick operations encourage usage
+3. **Safe over Convenient**: Always backup, confirm destructive operations
+4. **Profile-Aware over One-Size-Fits-All**: Smart defaults for machine types
+
+### Technical Stack
+- **Language**: Bash for maximum compatibility
+- **Package Sources**: npm, GitHub releases, system packages, repositories
+- **Sync**: Git-based with intelligent timing
+- **Detection**: Scoring algorithm for environment classification
+
+### Update Efficiency Innovation
+Instead of expensive operations like `npm update -g`, the system uses:
+
+```bash
+# Fast checking methods
+npm outdated -g --json          # No installs, just version comparison
+curl -s "https://api.github.com/repos/.../releases/latest"  # GitHub API
+Local version parsing           # Current installed versions
+
+# Selective updates
+Only outdated packages          # Skip up-to-date ones
+Profile filtering              # Server won't check Claude/Gemini
+Batch operations              # Update multiple efficiently
+```
+
+## Lessons Learned
+
+### What Worked Well
+1. **Profile auto-detection** eliminates setup friction
+2. **Caching update checks** makes frequent operations fast
+3. **Modular architecture** allows easy extension
+4. **Safety features** build confidence in automation
+
+### Gotchas and Solutions
+1. **Permission Issues**: Smart sudo detection and user prompting
+2. **Network Failures**: Graceful fallbacks and offline operation
+3. **Partial Installations**: Resume capability and detailed logging
+4. **Different Package Managers**: OS detection and appropriate commands
+
+## Future Enhancements
+
+### Planned Features
+- **Cloud Sync**: Beyond git, support for cloud storage backends
+- **Team Profiles**: Shared configurations for team consistency
+- **Plugin System**: Easy extension without core modifications
+- **GUI Dashboard**: Web interface for non-terminal users
+
+### Community Extensions
+- **Language-Specific Profiles**: Node.js dev, Python dev, Go dev
+- **Framework Profiles**: React, Django, Rails-specific setups
+- **Security Profiles**: Hardened configurations for security work
+- **Performance Profiles**: Optimized for different resource constraints
+
+## Try It Yourself
+
+### Quick Start (5 minutes)
+```bash
+# One-line installation
+curl -fsSL https://git.turnersrus.com/razzam21/dotfiles/-/raw/dev/install-web.sh | bash
+
+# Test the features
+dot sync status             # Check sync status
+dot profile                 # Show machine profile
+dot packages check-updates  # Check for updates
+dot reset --backup          # Create safety backup
+```
+
+### Available Profiles
+- **server**: Minimal server setup (curl, git, vim, sshuttle, ripgrep, fd)
+- **dev**: Full development setup (all tools + claude, gemini, docker)
+- **dev-lite**: Development without heavy packages (no docker)
+- **personal**: Personal machine (all tools including task-master)
+- **minimal**: Bare bones (curl, git, vim only)
+
+## The Big Picture
+
+This isn't just about dotfiles—it's about **intelligent infrastructure adaptation**. The same principles apply to:
+
+- **Container orchestration**: Different resources, different configurations
+- **CI/CD pipelines**: Development vs production needs  
+- **Application deployment**: Environment-appropriate features
+- **Cloud infrastructure**: Auto-scaling based on detected patterns
+
+## Conclusion
+
+The best configuration system is the one you never have to think about—it just works, adapts, and gets out of your way.
+
+By building intelligence into the dotfiles system, we've solved the multi-machine problem while maintaining the simplicity that makes dotfiles powerful. The system thinks so you don't have to.
+
+Whether you're managing 2 machines or 20, the smart dotfiles approach saves time, reduces errors, and ensures consistency without sacrificing appropriateness.
+
+---
+
+**Repository**: https://git.turnersrus.com/razzam21/dotfiles  
+**Version**: 1.0.0  
+**License**: MIT  
+
+*Star the repo if you find it useful, and feel free to contribute profiles for new machine types!*

README.md

@@ -19,7 +19,7 @@ Get your consistent terminal environment up and running in minutes!
 ### One-Line Installation (Recommended)
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | bash
+curl -fsSL https://git.turnersrus.com/razzam21/dotfiles/-/raw/dev/install-web.sh | bash
 ```
 *Replace `your-username/dotfiles` with the actual GitHub path to this repository.*
 

docs/BLOG_POST_GUIDE.md

@@ -0,0 +1,362 @@
+# Blog Post Guide: Building a Modern Dotfiles Management System
+
+This guide provides structured content for creating a comprehensive blog post about the dotfiles management system.
+
+## 🎯 Blog Post Structure
+
+### 1. Hook/Introduction
+**Title Ideas:**
+- "I Built an AI-Powered Dotfiles System That Adapts to Any Machine"
+- "How I Solved the Multi-Machine Development Environment Problem"
+- "From Chaos to Consistency: A Modern Approach to Dotfiles"
+- "The Dotfiles System That Thinks: Auto-Detection, Smart Updates, and More"
+
+**Opening Hook:**
+```
+Picture this: You SSH into a new server, and within 30 seconds, you have your 
+complete terminal environment—but only the tools you actually need. No Claude AI 
+on production servers, no Docker on lightweight VMs, but your favorite aliases 
+and shortcuts everywhere. This is the power of intelligent dotfiles management.
+```
+
+### 2. The Problem Section
+**Pain Points to Highlight:**
+
+1. **The Multi-Machine Problem**
+   - Different machines need different tools
+   - Servers shouldn't have development bloat
+   - Keeping configs in sync is a nightmare
+
+2. **The Update Dilemma**
+   - `npm update -g` takes forever
+   - You never know what needs updating
+   - Manual checking across 10+ packages
+
+3. **The Consistency Challenge**
+   - Same shortcuts should work everywhere
+   - But package sets should be machine-appropriate
+   - Reset to vanilla should be one command
+
+### 3. The Solution Overview
+**Key Innovation Points:**
+
+1. **Machine Profile Auto-Detection**
+   ```bash
+   # System automatically detects:
+   - Server (SSH connection, systemd, no GUI)
+   - Development (code editors, dev tools, GUI)
+   - Personal (browsers, personal directories)
+   - Minimal (fallback for unknown environments)
+   ```
+
+2. **Intelligent Package Management**
+   ```bash
+   # Server profile gets:
+   curl, git, vim, sshuttle, ripgrep, fd
+   
+   # Dev profile adds:
+   claude-code, gemini-cli, fzf, bat, delta, docker
+   
+   # Personal profile adds:
+   task-master, all convenience tools
+   ```
+
+3. **Smart Sync & Updates**
+   ```bash
+   # Traditional approach
+   npm update -g  # 30-60 seconds, updates everything
+   
+   # Smart approach  
+   dotupdatecheck # 2-5 seconds, fast version checking
+   dotupdate      # 10-20 seconds, only outdated packages
+   ```
+
+### 4. Technical Deep Dive
+
+#### Profile Detection Algorithm
+```bash
+# The system scores different indicators:
+
+Server Indicators:
+├── systemd active (30 points)
+├── SSH connection (25 points)
+├── Multi-user target (20 points)
+└── No logged users (10 points)
+
+Development Indicators:
+├── Dev tools present (30 points)
+├── Code editor available (25 points)  
+├── Dev directories exist (20 points)
+└── GUI environment (15 points)
+
+# Highest score wins, determines package set
+```
+
+#### Update Efficiency Innovation
+```bash
+# Instead of expensive operations:
+npm update -g                    # Slow, updates everything
+
+# Use fast checking:
+npm outdated -g --json          # Fast, just version comparison
+curl -s "https://api.github.com/repos/.../releases/latest"  # GitHub API
+
+# Cache results, update selectively
+```
+
+#### Architecture Diagram
+```
+User Types Command
+       ↓
+Profile Detection
+       ↓
+Package Filtering
+       ↓
+Efficient Installation
+       ↓
+Universal Shortcuts Available
+```
+
+### 5. Code Examples Section
+
+#### Installation Experience
+```bash
+$ cd ~ && git clone <repo> .dotfiles && cd .dotfiles
+$ ./install.sh
+
+🤖 Machine Profile Detection
+==============================
+Detected profile: dev
+
+Available profiles:
+  server    - Minimal server setup
+  dev       - Full development setup  
+  dev-lite  - Development without heavy packages
+  personal  - Personal machine (all tools)
+  minimal   - Bare bones
+
+Use detected profile 'dev'? [Y/n]: Y
+✅ Profile set to: dev
+
+📦 Checking system packages...
+  ✅ curl already installed
+  Installing git...
+  ✅ git installed successfully
+
+⚡ Checking binary packages...
+  Installing claude-code...
+  ✅ claude-code installed successfully
+  
+🎉 Dotfiles installation complete!
+```
+
+#### Daily Usage
+```bash
+# Check for updates (fast)
+$ dotupdatecheck
+🔍 Checking npm packages for updates...
+  📦 @anthropic-ai/claude-code: 2.1.0 → 2.2.0
+  ✅ @google/gemini-cli: 1.5.2 (latest)
+
+💡 Updates available! Run 'dotupdate' to install them.
+
+# Install only needed updates
+$ dotupdate
+🔄 Updating packages...
+  Updating: @anthropic-ai/claude-code
+  ✅ Updated npm packages
+🎉 Package updates completed!
+```
+
+#### Profile Switching
+```bash
+# Moving to a new machine type
+$ dotprofileset server
+✅ Profile set to: server
+🔄 Run 'dotinstall' to apply profile changes
+
+$ dotinstall
+📦 Checking system packages for profile: server
+  ✅ curl already installed
+  ✅ git already installed  
+  ✅ vim already installed
+  Installing sshuttle...
+  ✅ sshuttle installed successfully
+
+⚡ Skipping development packages (server profile)
+🎉 Package check completed!
+```
+
+### 6. Real-World Benefits
+
+#### Before/After Comparison
+
+**Before (Traditional Dotfiles):**
+```bash
+# Same heavy config on every machine
+- Production server running Docker & development tools
+- 5-minute setup time per machine
+- Manual package management
+- Inconsistent environments
+- No easy way to reset/clean
+```
+
+**After (Smart Dotfiles):**
+```bash
+# Adaptive configuration
+- Server gets only essential tools
+- 30-second setup with auto-detection
+- Automatic package management & updates
+- Consistent shortcuts, appropriate tools
+- One-command reset to vanilla
+```
+
+#### Performance Metrics
+```bash
+Terminal Startup Time:
+├── Cold start (with sync): ~2 seconds
+├── Warm start: ~0.1 seconds  
+└── Background operations: Non-blocking
+
+Update Efficiency:
+├── Traditional: npm update -g (30-60 seconds)
+├── Smart check: dotupdatecheck (2-5 seconds)
+└── Selective update: dotupdate (10-20 seconds)
+
+Resource Usage:
+├── Memory: Minimal (shell functions only)
+├── Disk: ~50MB for full dev profile
+└── Network: Efficient API calls, cached results
+```
+
+### 7. Advanced Features
+
+#### Reset System
+```bash
+# Safety-first reset options
+$ dotreset
+Choose reset level:
+1) Soft Reset   - Remove symlinks, restore original configs
+2) Hard Reset   - Soft + uninstall packages  
+3) Nuclear Reset - Hard + remove dotfiles directory
+4) Backup Only  - Create backup without changes
+
+# Always creates backup before any changes
+📦 Creating backup of current dotfiles...
+✅ Backup created at: /home/user/dotfiles_backup_20250115_143022
+```
+
+#### Universal Command Interface
+```bash
+# These work on ALL machines, regardless of profile:
+g                    # git
+ga                   # git add  
+gs                   # git status
+..                   # cd ..
+l                    # ls -lah
+ports                # netstat -tuln
+myip                 # curl ifconfig.me
+
+# Profile-specific commands only available where appropriate:
+claude               # Only on dev/personal machines
+tm                   # task-master, only on personal machines
+```
+
+### 8. Lessons Learned
+
+#### Design Principles
+1. **Adaptive over Universal**: Different machines have different needs
+2. **Fast over Comprehensive**: Quick operations encourage usage
+3. **Safe over Convenient**: Always backup, confirm destructive operations
+4. **Profile-Aware over One-Size-Fits-All**: Smart defaults for machine types
+
+#### Technical Decisions
+1. **Bash over Modern Languages**: Maximum compatibility
+2. **Profile Detection over Manual Configuration**: Reduce setup friction  
+3. **Caching over Real-time**: Better performance for frequent operations
+4. **Modular over Monolithic**: Easy to extend and maintain
+
+#### Gotchas and Solutions
+1. **Permission Issues**: Smart sudo detection and user prompting
+2. **Network Failures**: Graceful fallbacks and offline operation
+3. **Partial Installations**: Resume capability and detailed logging
+4. **Different Package Managers**: OS detection and appropriate commands
+
+### 9. Future Enhancements
+
+#### Planned Features
+- **Cloud Sync**: Beyond git, support for cloud storage backends
+- **Team Profiles**: Shared configurations for team consistency
+- **Plugin System**: Easy extension without core modifications
+- **GUI Dashboard**: Web interface for non-terminal users
+
+#### Community Extensions
+- **Language-Specific Profiles**: Node.js dev, Python dev, Go dev
+- **Framework Profiles**: React, Django, Rails-specific setups
+- **Security Profiles**: Hardened configurations for security work
+- **Performance Profiles**: Optimized for different resource constraints
+
+### 10. Call to Action
+
+#### Try It Yourself
+```bash
+# Quick start (5 minutes)
+cd ~ && git clone <repo> .dotfiles
+cd .dotfiles && chmod +x install.sh && ./install.sh
+
+# Test the features
+dotstatus           # Check sync status
+dotprofile          # Show machine profile
+dotupdatecheck      # Check for updates
+dotreset --backup   # Create safety backup
+```
+
+#### Contribute
+- **Star the repo** if you find it useful
+- **Submit issues** for bugs or feature requests  
+- **Contribute profiles** for new machine types
+- **Share your customizations** with the community
+
+### 11. Conclusion Points
+
+**Key Takeaways:**
+1. **Intelligent automation** beats manual configuration
+2. **Machine-appropriate tools** are better than everything everywhere
+3. **Fast operations** encourage good habits
+4. **Safety features** enable confidence in automation
+
+**The Big Picture:**
+This isn't just about dotfiles—it's about **intelligent infrastructure adaptation**. The same principles apply to:
+- Container orchestration (different resources, different configurations)
+- CI/CD pipelines (development vs production needs)
+- Application deployment (environment-appropriate features)
+
+**Final Thought:**
+*"The best configuration system is the one you never have to think about—it just works, adapts, and gets out of your way."*
+
+## 📊 Blog Post Metrics
+
+**Estimated Reading Time:** 12-15 minutes
+**Target Audience:** Developers, DevOps engineers, system administrators
+**Technical Level:** Intermediate to Advanced
+**Key SEO Terms:** dotfiles, development environment, automation, configuration management
+
+## 📸 Visual Content Ideas
+
+1. **Before/After Terminal Screenshots**
+2. **Profile Detection Flow Diagram**  
+3. **Package Installation Timeline Comparison**
+4. **Architecture Overview Diagram**
+5. **Command Interface Reference Card**
+6. **Performance Benchmarks Chart**
+
+## 🎬 Demo Script Ideas
+
+1. **30-Second Setup Demo**: Clone → Install → Working environment
+2. **Profile Switching Demo**: Server → Dev → Personal transitions
+3. **Update Workflow Demo**: Check → Review → Update only needed packages
+4. **Reset Demo**: Full reset back to vanilla in under a minute
+
+---
+
+*This blog post guide provides all the content needed for a comprehensive technical blog post about the dotfiles management system.*

docs/INSTALLATION.md

@@ -0,0 +1,401 @@
+# Installation Guide
+
+Complete installation guide for the Modern Dotfiles Management System.
+
+## 🚀 Quick Start (5 Minutes)
+
+### Prerequisites
+- Git installed
+- Bash or Zsh shell
+- Internet connection for package downloads
+
+### One-Line Installation
+```bash
+cd ~ && git clone https://git.turnersrus.com/razzam21/dotfiles .dotfiles && cd .dotfiles && chmod +x install.sh && ./install.sh
+```
+
+### Step-by-Step Installation
+
+1. **Clone the repository**
+   ```bash
+   cd ~
+   git clone https://git.turnersrus.com/razzam21/dotfiles .dotfiles
+   cd .dotfiles
+   ```
+
+2. **Make installation script executable**
+   ```bash
+   chmod +x install.sh
+   ```
+
+3. **Run the installer**
+   ```bash
+   ./install.sh
+   ```
+
+4. **Follow the interactive prompts**
+   - System will auto-detect your machine type
+   - Confirm or change the detected profile
+   - Wait for package installation to complete
+
+5. **Restart your shell**
+   ```bash
+   exec $SHELL
+   ```
+
+## 🤖 Installation Process Walkthrough
+
+### Profile Detection
+```bash
+🤖 Machine Profile Detection
+==============================
+Detected profile: dev
+
+Available profiles:
+  server    - Minimal server setup (curl, git, vim, sshuttle, ripgrep, fd)
+  dev       - Full development setup (all tools + claude, gemini, docker)
+  dev-lite  - Development without heavy packages (no docker)
+  personal  - Personal machine (all tools including task-master)
+  minimal   - Bare bones (curl, git, vim only)
+
+Use detected profile 'dev'? [Y/n/choose]: 
+```
+
+**Profile Detection Logic:**
+- **Server**: SSH connection, systemd services, no GUI
+- **Development**: Code editors, dev directories, development tools
+- **Personal**: Desktop directories, browsers, personal home paths
+- **Minimal**: Fallback for unknown environments
+
+### Package Installation
+```bash
+📦 Checking system packages...
+  ✅ curl already installed
+  Installing git...
+  ✅ git installed successfully
+  Installing vim...
+  ✅ vim installed successfully
+  Installing sshuttle...
+  ✅ sshuttle installed successfully
+
+⚡ Checking binary packages...
+  Installing claude-code...
+  ✅ claude-code installed successfully
+  💡 Run 'claude doctor' to verify installation
+  Installing gemini-cli...
+  ✅ gemini-cli installed successfully
+
+🐙 Checking GitHub packages...
+  Installing fzf...
+  ✅ fzf installed successfully
+  Installing bat...
+  ✅ bat installed successfully
+  Installing ripgrep...
+  ✅ ripgrep installed successfully
+  Installing fd...
+  ✅ fd installed successfully
+  Installing delta...
+  ✅ delta installed successfully
+
+🎨 Checking zsh plugins...
+  Installing zsh-syntax-highlighting...
+  ✅ zsh-syntax-highlighting installed successfully
+  Installing zsh-autosuggestions...
+  ✅ zsh-autosuggestions installed successfully
+```
+
+### Configuration Linking
+```bash
+🔗 Linking configuration files...
+📦 Backing up existing /home/user/.bashrc
+🔗 Linked /home/user/.dotfiles/bash/.bashrc -> /home/user/.bashrc
+📦 Backing up existing /home/user/.gitconfig
+🔗 Linked /home/user/.dotfiles/git/.gitconfig -> /home/user/.gitconfig
+🔗 Linked /home/user/.dotfiles/vim/.vimrc -> /home/user/.vimrc
+✅ Configured for zsh
+```
+
+## 🎯 Profile-Specific Installation
+
+### Server Profile Installation
+```bash
+# For minimal server environments
+./install.sh
+
+# Or force server profile
+echo "server" > .machine_profile
+./install.sh
+
+# Packages installed:
+# - curl, git, vim, sshuttle (system)
+# - ripgrep, fd (GitHub tools for log analysis)
+# - No development tools, no GUI applications
+```
+
+### Development Profile Installation
+```bash
+# Full development environment
+./install.sh
+
+# Or force development profile
+echo "dev" > .machine_profile
+./install.sh
+
+# Packages installed:
+# - All system packages
+# - Claude AI, Gemini CLI, Task Master
+# - Modern CLI tools (fzf, bat, ripgrep, fd, delta)
+# - Docker, docker-compose
+# - Zsh plugins and enhancements
+```
+
+### Development Lite Profile
+```bash
+# Development without heavy packages
+echo "dev-lite" > .machine_profile
+./install.sh
+
+# Packages installed:
+# - Development tools (claude, gemini)
+# - Modern CLI tools
+# - No Docker/containers (lighter footprint)
+```
+
+## 🔧 Advanced Installation Options
+
+### Silent Installation
+```bash
+# Skip interactive prompts (uses auto-detected profile)
+DOTFILES_SILENT=true ./install.sh
+```
+
+### Force Profile Installation
+```bash
+# Set specific profile before installation
+echo "server" > ~/.dotfiles/.machine_profile
+./install.sh
+```
+
+### Partial Installation
+```bash
+# Install only configurations (no packages)
+DOTFILES_CONFIG_ONLY=true ./install.sh
+
+# Install only packages (no config linking)
+DOTFILES_PACKAGES_ONLY=true ./install.sh
+```
+
+### Custom Package Sets
+```bash
+# Skip optional packages
+DOTFILES_SKIP_OPTIONAL=true ./install.sh
+
+# Skip npm packages (if npm not available)
+DOTFILES_SKIP_NPM=true ./install.sh
+
+# Skip GitHub packages (if network limited)
+DOTFILES_SKIP_GITHUB=true ./install.sh
+```
+
+## 🌍 Platform-Specific Instructions
+
+### Ubuntu/Debian
+```bash
+# Update package list first
+sudo apt update
+
+# Install prerequisites if missing
+sudo apt install -y git curl
+
+# Standard installation
+cd ~ && git clone <repo> .dotfiles && cd .dotfiles && ./install.sh
+```
+
+### CentOS/RHEL/Fedora
+```bash
+# Install prerequisites
+sudo yum install -y git curl  # CentOS/RHEL
+sudo dnf install -y git curl  # Fedora
+
+# Standard installation
+cd ~ && git clone <repo> .dotfiles && cd .dotfiles && ./install.sh
+```
+
+### macOS
+```bash
+# Install Homebrew if not present (installer will do this)
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+
+# Standard installation
+cd ~ && git clone <repo> .dotfiles && cd .dotfiles && ./install.sh
+```
+
+### WSL (Windows Subsystem for Linux)
+```bash
+# WSL automatically detected, uses Linux package methods
+cd ~ && git clone <repo> .dotfiles && cd .dotfiles && ./install.sh
+
+# Note: GUI applications may have limited functionality
+```
+
+## 🔄 Post-Installation Setup
+
+### Verify Installation
+```bash
+# Check dotfiles status
+dot sync status
+
+# Check installed packages
+dot packages
+
+# Check machine profile
+dot profile
+```
+
+### Test Key Features
+```bash
+# Test universal aliases
+l                    # Should show 'ls -lah'
+g                    # Should show git help
+..                   # Should change to parent directory
+
+# Test profile-specific tools (if dev profile)
+claude --version     # Should show Claude AI version
+gemini --help        # Should show Gemini CLI help
+fzf --version        # Should show fzf version
+```
+
+### Configure Git (First Time Setup)
+```bash
+# Update git configuration with your details
+git config --global user.name "Your Name"
+git config --global user.email "your.email@example.com"
+```
+
+### Configure AI Tools (Development Profiles)
+```bash
+# Claude AI setup
+claude auth login
+
+# Gemini CLI setup (if using)
+gemini auth login
+
+# Task Master setup (personal profile)
+task-master init
+```
+
+## 🛠️ Troubleshooting Installation
+
+### Common Issues
+
+#### Permission Errors
+```bash
+# If you see permission denied errors:
+sudo chown -R $USER:$USER ~/.dotfiles
+chmod +x ~/.dotfiles/install.sh
+```
+
+#### Package Manager Not Found
+```bash
+# On minimal systems, install package manager first:
+# Ubuntu/Debian: Package manager (apt) should be pre-installed
+# CentOS: yum should be pre-installed
+# macOS: Installer will install Homebrew automatically
+```
+
+#### Network/Firewall Issues
+```bash
+# If GitHub downloads fail:
+DOTFILES_SKIP_GITHUB=true ./install.sh
+
+# If npm installs fail:
+DOTFILES_SKIP_NPM=true ./install.sh
+
+# Install manually later:
+dot packages install
+```
+
+#### Shell Not Supported
+```bash
+# If you're using a shell other than bash/zsh:
+# 1. Install bash or zsh first
+# 2. Switch to supported shell: exec bash
+# 3. Run installation: ./install.sh
+```
+
+### Debug Mode
+```bash
+# Run installer with debug output
+DOTFILES_DEBUG=true ./install.sh
+
+# Check installation logs
+cat ~/.dotfiles/.package.log
+cat ~/.dotfiles/.profile.log
+```
+
+### Manual Recovery
+```bash
+# If installation fails partway through:
+# 1. Check what was installed
+dot packages
+
+# 2. Try installing missing packages
+dotcheck
+
+# 3. Or reset and start over
+dot reset --soft
+./install.sh
+```
+
+## 🔐 Security Considerations
+
+### What Gets Installed
+- **System packages**: Only well-known, trusted packages
+- **npm packages**: Official packages from Anthropic, Google
+- **GitHub releases**: Downloaded from official repositories
+- **No sudo escalation**: Scripts request permission when needed
+
+### Network Access
+- **Package managers**: Standard repositories (apt, npm, homebrew)
+- **GitHub API**: For latest release information
+- **No arbitrary scripts**: All installations use standard package managers
+
+### File Permissions
+- **User-level installation**: No system-wide changes required
+- **Backup creation**: Existing configs backed up before changes
+- **Symlink verification**: Only creates expected symlinks
+
+## 📝 Installation Logs
+
+### Log Locations
+```bash
+~/.dotfiles/.package.log     # Package installation log
+~/.dotfiles/.profile.log     # Profile detection log
+~/.dotfiles/.sync.log        # Sync operation log
+~/.dotfiles_backup_*         # Configuration backups
+```
+
+### Log Analysis
+```bash
+# Check recent installation activity
+tail -20 ~/.dotfiles/.package.log
+
+# Check profile detection reasoning
+cat ~/.dotfiles/.profile.log
+
+# Find backup locations
+ls -la ~/ | grep dotfiles_backup
+```
+
+## 🔄 Next Steps
+
+After successful installation:
+
+1. **Learn the commands**: [Configuration Reference](CONFIGURATION.md)
+2. **Customize settings**: Edit files in `~/.dotfiles/shared/`
+3. **Set up sync**: Configure git credentials for automatic sync
+4. **Explore features**: Try `dot packages check-updates`, `dot profile`, `dot sync status`
+
+---
+
+*Installation complete! Your intelligent dotfiles system is ready to use.*

docs/ONE_LINE_INSTALL.md

@@ -0,0 +1,211 @@
+# One-Line Installation Guide
+
+## 🚀 Super Easy Installation
+
+### The Magic Command
+```bash
+curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash
+```
+
+**That's it!** Copy, paste, and press Enter. Your intelligent dotfiles system will be ready in 30 seconds.
+
+## 🎯 What This Command Does
+
+1. **Downloads** the web installer script
+2. **Auto-detects** your machine type (server/dev/personal)
+3. **Installs** appropriate packages for your profile
+4. **Configures** universal aliases and shortcuts
+5. **Sets up** automatic syncing and updates
+
+## 🛡️ Security First
+
+Before running any script from the internet, you should review it:
+
+**View the installer script:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh
+```
+
+**What the script does:**
+- ✅ Only installs from trusted package repositories
+- ✅ Creates backups before making changes
+- ✅ Uses standard package managers (apt, npm, brew)
+- ✅ No hidden or obfuscated code
+- ✅ All operations logged for transparency
+
+## 📱 Copy-Paste Ready Commands
+
+### For Different Scenarios
+
+#### Standard Installation (Recommended)
+```bash
+curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash
+```
+
+#### Silent Installation (No Prompts)
+```bash
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_SILENT=true bash
+```
+
+#### Force Specific Profile
+```bash
+# Server profile
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_PROFILE=server bash
+
+# Development profile
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_PROFILE=dev bash
+
+# Personal profile
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_PROFILE=personal bash
+```
+
+#### Skip Optional Packages (Faster)
+```bash
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_SKIP_OPTIONAL=true bash
+```
+
+## 🎮 After Installation
+
+### Verify Everything Works
+```bash
+# Check system status
+dot sync status
+
+# Check your profile
+dot profile
+
+# Check installed packages
+dot packages
+
+# Try some shortcuts
+l              # Enhanced file listing
+g              # Git shortcut
+..             # Go up directory
+```
+
+### Get Help
+```bash
+# Show all available commands
+alias | grep dot
+
+# Read documentation
+cat ~/.dotfiles/docs/README.md
+```
+
+## 🔧 Troubleshooting One-Liners
+
+### If Installation Fails
+```bash
+# Check what went wrong
+cat ~/.dotfiles/.package.log
+
+# Try installing packages manually
+cd ~/.dotfiles && ./install.sh
+
+# Reset and try again
+cd ~/.dotfiles && ./reset.sh --soft && ./install.sh
+```
+
+### If Network Issues
+```bash
+# Install without GitHub packages
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_SKIP_GITHUB=true bash
+
+# Install without npm packages
+curl -fsSL https://raw.githubusercontent.com/your-username/dotfiles/main/install-web.sh | DOTFILES_SKIP_NPM=true bash
+```
+
+### Manual Installation (If curl fails)
+```bash
+# Clone and install manually
+git clone https://git.turnersrus.com/razzam21/dotfiles ~/.dotfiles
+cd ~/.dotfiles && chmod +x install.sh && ./install.sh
+```
+
+## 📋 Platform-Specific One-Liners
+
+### Ubuntu/Debian
+```bash
+# Install prerequisites and dotfiles
+sudo apt update && sudo apt install -y curl git && curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash
+```
+
+### CentOS/RHEL
+```bash
+# Install prerequisites and dotfiles
+sudo yum install -y curl git && curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash
+```
+
+### macOS
+```bash
+# Install Xcode tools and dotfiles (if needed)
+xcode-select --install 2>/dev/null || true && curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash
+```
+
+### WSL (Windows)
+```bash
+# Same as Ubuntu (WSL uses Ubuntu packages)
+curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash
+```
+
+## 🌐 Web Page for Easy Copying
+
+For the ultimate user experience, host the `WEB_INSTALL_PAGE.html` on your website. Users can then:
+
+1. **Visit** your installation page
+2. **Click** the copy button
+3. **Paste** into their terminal
+4. **Enjoy** their new dotfiles system
+
+### Example hosting locations:
+- `https://your-domain.com/dotfiles`
+- `https://your-username.github.io/dotfiles`
+- GitHub Pages, Netlify, Vercel, etc.
+
+## 🚀 Marketing-Ready Copy-Paste
+
+### For Social Media
+```
+🚀 Transform your terminal in 30 seconds!
+
+One command installs an intelligent dotfiles system that adapts to your machine type:
+• Servers get minimal tools
+• Dev machines get AI assistants
+• Same shortcuts everywhere
+
+curl -fsSL https://your-domain.com/install | bash
+
+#dotfiles #terminal #productivity
+```
+
+### For README/Documentation
+```markdown
+## Quick Start
+
+```bash
+curl -fsSL https://your-domain.com/install | bash
+```
+
+This command will:
+- Auto-detect your machine type
+- Install appropriate tools
+- Set up universal shortcuts
+- Configure automatic updates
+```
+
+### For Email Signatures
+```
+P.S. Want a better terminal experience? Try: curl -fsSL https://your-domain.com/install | bash
+```
+
+## 💡 Tips for Maximum Adoption
+
+1. **Use a short URL**: `your-domain.com/install` is easier to remember
+2. **Host the HTML page**: Visual instructions increase confidence
+3. **Include security note**: Shows you care about user safety
+4. **Provide multiple options**: Silent, profile-specific, etc.
+5. **Make it copyable**: Big copy buttons, clear commands
+
+---
+
+*One command. Infinite possibilities. Your new terminal experience is just a paste away.*

docs/README.md

@@ -0,0 +1,404 @@
+# Modern Dotfiles Management System
+
+A comprehensive, intelligent dotfiles management system that provides consistent terminal environments across multiple machines while adapting to different machine types (servers vs development machines).
+
+## 🎯 Project Overview
+
+This dotfiles system solves the common problem of maintaining consistent development environments across multiple machines with different purposes. Whether you're working on a minimal server, a full development machine, or anything in between, this system adapts to provide exactly what you need without bloat.
+
+### Key Problems Solved
+
+1. **Machine Type Awareness**: Servers don't need Claude AI or Docker, but development machines do
+2. **Sync Efficiency**: Updates only when needed, not every terminal session
+3. **Package Management**: Automatically installs and updates tools from multiple sources
+4. **Configuration Consistency**: Same aliases and shortcuts everywhere
+5. **Easy Reset**: Can completely restore system to vanilla state
+
+## 🏗️ Architecture
+
+```
+~/.dotfiles/
+├── install.sh              # Main installation script
+├── sync.sh                  # Auto-sync with git repository
+├── reset.sh                 # Reset to vanilla state
+├── machine-profiles.yaml   # Machine type definitions
+├── packages.yaml           # Package definitions
+├── bash/                   # Bash-specific configurations
+├── zsh/                    # Zsh-specific configurations  
+├── shared/                 # Universal configurations
+├── git/                    # Git configuration
+├── vim/                    # Vim configuration
+├── lib/                    # Core libraries
+└── docs/                   # Documentation
+```
+
+## 🤖 Machine Profiles
+
+The system automatically detects and configures based on machine type:
+
+### Server Profile
+- **Purpose**: Minimal server setup
+- **Packages**: `curl`, `git`, `vim`, `sshuttle`, `ripgrep`, `fd`
+- **Use Case**: Production servers, minimal VMs
+- **Auto-detection**: SSH connections, systemd services, no GUI
+
+### Development Profile  
+- **Purpose**: Full development environment
+- **Packages**: All tools including Claude AI, Gemini CLI, Docker, modern CLI tools
+- **Use Case**: Primary development machines
+- **Auto-detection**: Code editors, development directories, Node.js/Python
+
+### Development Lite Profile
+- **Purpose**: Development without heavy packages
+- **Packages**: Development tools but no Docker/containers
+- **Use Case**: Lightweight VMs, resource-constrained machines
+- **Auto-detection**: Development tools present but limited resources
+
+### Personal Profile
+- **Purpose**: Personal machines with all conveniences
+- **Packages**: Everything including task management tools
+- **Use Case**: Personal laptops, home workstations
+- **Auto-detection**: Personal directories, browsers, GUI environment
+
+### Minimal Profile
+- **Purpose**: Absolute bare bones
+- **Packages**: `curl`, `git`, `vim` only
+- **Use Case**: Emergency access, extremely limited environments
+
+## 🔄 Intelligent Sync System
+
+### Auto-Sync Features
+- **Daily sync**: Automatically syncs once per day maximum
+- **Background operation**: Non-blocking terminal startup
+- **Smart timing**: Won't sync more than once per 24 hours
+- **Manual override**: Force sync anytime with `dotsync`
+
+### Update Management
+- **Efficient checking**: Fast update detection without expensive operations
+- **Selective updates**: Only updates packages that actually need it
+- **Cross-source support**: npm, GitHub releases, system packages
+- **Profile-aware**: Only checks packages relevant to current machine type
+
+## 📦 Package Management
+
+### Supported Package Sources
+1. **System packages**: apt/yum/brew (curl, git, vim, sshuttle)
+2. **npm packages**: Claude AI, Gemini CLI, Task Master  
+3. **GitHub releases**: Modern CLI tools (bat, ripgrep, fzf, fd, delta)
+4. **Repository clones**: Tools requiring custom installation
+5. **Oh My Zsh plugins**: Shell enhancements
+
+### Installation Methods
+- **Automatic detection**: OS and package manager detection
+- **Fallback strategies**: Multiple installation methods per package
+- **Error handling**: Graceful failures with helpful messages
+- **Logging**: Detailed installation logs for troubleshooting
+
+## 🎮 Command Interface
+
+The system uses an intuitive `dot <action> [subaction] [flags]` command structure:
+
+```bash
+# Installation and setup
+./install.sh                # Initial setup with profile detection
+dot help                    # Show all available commands
+dot version                 # Show version information
+
+# Sync Management
+dot sync                    # Manual sync now
+dot sync --force            # Force sync (ignore timing limits)
+dot sync status             # Show sync status and last update
+dot sync on                 # Enable automatic syncing
+dot sync off                # Disable automatic syncing
+
+# Package Management
+dot packages                # Show package status for current profile
+dot packages install        # Install all packages for current profile
+dot packages check          # Check package installation status
+dot packages update         # Install pending updates
+dot packages check-updates  # Check for package updates (fast)
+dot packages status         # Show update status
+
+# Profile Management
+dot profile                 # Show current machine profile
+dot profile set <name>      # Switch to specified profile (server/dev/personal)
+dot profile detect          # Re-detect machine type
+
+# Reset and Cleanup
+dot reset                   # Interactive reset menu
+dot reset --soft            # Remove configs, restore originals
+dot reset --hard            # Soft reset + uninstall packages
+dot reset --nuclear         # Complete removal (back to vanilla)
+```
+
+### Universal Aliases (Available on All Machines)
+```bash
+# Navigation
+..                          # cd ..
+...                         # cd ../..
+~                           # cd ~
+
+# File operations
+l                           # ls -lah  
+ll                          # ls -l
+la                          # ls -la
+
+# Git shortcuts
+g                           # git
+ga                          # git add
+gc                          # git commit
+gp                          # git push
+gs                          # git status
+
+# System monitoring
+df                          # df -h
+free                        # free -h
+ps                          # ps aux
+
+# Network
+ports                       # netstat -tuln
+myip                        # curl ifconfig.me
+
+# Package management (Debian/Ubuntu)
+apt-update                  # sudo apt update && sudo apt upgrade
+apt-install                 # sudo apt install
+```
+
+### Profile-Specific Aliases
+```bash
+# Development machines only
+tm                          # task-master
+claude                      # Claude AI CLI
+gemini                      # Gemini CLI
+
+# SSH tunneling (server + dev)
+sshuttle-vpn               # Base VPN command
+sshuttle-txtwire           # Specific VPN connection
+```
+
+### Git Remote URL Conversion
+The system includes convenient functions to convert git remote URLs between SSH and HTTPS formats:
+
+```bash
+# Automatic conversion (detects current format and converts to opposite)
+git-remote-toggle          # Toggle between SSH/HTTPS for origin
+git-remote-toggle upstream # Toggle for specific remote
+
+# Convert to specific format
+git-remote-ssh             # Convert origin to SSH format
+git-remote-https           # Convert origin to HTTPS format
+git-remote-ssh upstream    # Convert specific remote to SSH
+
+# Advanced usage with confirmation prompts
+git-convert origin ssh     # Convert origin to SSH with confirmation
+git-convert origin https   # Convert origin to HTTPS with confirmation
+```
+
+**Supported URL formats:**
+- SSH: `git@github.com:user/repo.git` 
+- HTTPS: `https://github.com/user/repo.git`
+- HTTPS (no .git): `https://github.com/user/repo`
+
+**Example usage:**
+```bash
+# Check current remote
+git remote -v
+# origin  https://github.com/user/repo.git (fetch)
+# origin  https://github.com/user/repo.git (push)
+
+# Convert to SSH
+git-remote-ssh
+# 🔄 Converting git remote 'origin'
+#    From (https): https://github.com/user/repo.git
+#    To   (ssh): git@github.com:user/repo.git
+# Proceed with conversion? [y/N]: y
+# ✅ Successfully converted remote 'origin'
+
+# Toggle back to HTTPS
+git-remote-toggle
+# 🔄 Converting git remote 'origin'
+#    From (ssh): git@github.com:user/repo.git  
+#    To   (https): https://github.com/user/repo.git
+```
+
+## 🔧 Technical Implementation
+
+### Profile Detection Algorithm
+The system uses a scoring algorithm to detect machine type:
+
+```bash
+# Server indicators (weight)
+- systemd active (30 points)
+- SSH connection (25 points)  
+- Multi-user target (20 points)
+- No logged users (10 points)
+
+# Development indicators  
+- Development tools present (30 points)
+- Code editor available (25 points)
+- Dev directories exist (20 points)
+- GUI environment (15 points)
+
+# Personal indicators
+- Personal directories (20 points)
+- Browser available (25 points)
+- Personal home path (15 points)
+```
+
+### Update Checking Strategy
+```bash
+# Fast check methods
+npm outdated -g --json      # No installs, just version comparison
+GitHub API calls            # Latest release info
+Local version parsing       # Current installed versions
+
+# Selective updates
+Only outdated packages      # Skip up-to-date ones
+Profile filtering          # Server won't check Claude/Gemini
+Batch operations          # Update multiple efficiently
+```
+
+### Sync Optimization
+```bash
+# Timing controls
+24-hour auto-sync limit    # Prevent excessive git operations
+5-minute manual override   # Allow frequent manual syncing
+Background execution       # Non-blocking terminal startup
+
+# Change detection
+Git fetch + compare        # Check for remote changes
+Local diff detection       # Handle local modifications
+Automatic stash/restore    # Preserve local changes
+```
+
+## 🛡️ Safety Features
+
+### Backup System
+- **Pre-installation backup**: All existing configs saved
+- **Timestamped backups**: Never overwrites previous backups
+- **Symlink detection**: Preserves existing dotfiles setups
+- **Restoration capability**: Can restore original configs
+
+### Reset Capabilities
+- **Soft reset**: Remove dotfiles, restore originals
+- **Hard reset**: Also uninstall packages
+- **Nuclear reset**: Complete removal
+- **Safety prompts**: Confirmation for destructive operations
+
+### Error Handling
+- **Graceful failures**: Continue on non-critical errors
+- **Detailed logging**: All operations logged with timestamps
+- **Rollback capability**: Can undo changes if needed
+- **Dependency checking**: Verify requirements before installation
+
+## 📈 Performance Characteristics
+
+### Startup Time
+- **Cold start**: ~2 seconds (first terminal of day with sync)
+- **Warm start**: ~0.1 seconds (subsequent terminals)
+- **Background sync**: Non-blocking, invisible to user
+
+### Update Efficiency
+- **Traditional approach**: `npm update -g` (30-60 seconds)
+- **Smart checking**: `dotupdatecheck` (2-5 seconds)
+- **Selective updates**: Only outdated packages (10-20 seconds)
+
+### Resource Usage
+- **Memory footprint**: Minimal (shell functions only)
+- **Disk usage**: ~50MB for full dev profile
+- **Network usage**: Efficient API calls, cached results
+
+## 🎯 Use Cases
+
+### Scenario 1: DevOps Engineer
+**Need**: Consistent tools across 20+ servers and 3 development machines
+
+**Solution**:
+- Servers get `server` profile (minimal, essential tools only)
+- Development machines get `dev` profile (full toolchain)
+- Same aliases and shortcuts everywhere
+- Auto-sync keeps everything updated
+
+### Scenario 2: Full-Stack Developer
+**Need**: Rich development environment that's portable
+
+**Solution**:
+- `personal` profile on main machine (everything)
+- `dev-lite` profile on cloud VMs (no Docker overhead)
+- Universal shortcuts for Git, navigation, system monitoring
+- Automatic package updates
+
+### Scenario 3: System Administrator
+**Need**: Minimal, secure server environments
+
+**Solution**:
+- `server` or `minimal` profiles
+- Essential tools only (no AI assistants, development tools)
+- Same navigation and system aliases
+- Easy reset to vanilla if needed
+
+## 🚀 Getting Started
+
+### Quick Start
+```bash
+# Clone the repository
+cd ~
+git clone <repository-url> .dotfiles
+cd .dotfiles
+
+# Run installation (will auto-detect machine type)
+chmod +x install.sh
+./install.sh
+
+# Restart shell or source configs
+exec $SHELL
+```
+
+### Customization
+```bash
+# Change machine profile
+dot profile set dev-lite
+dot packages install
+
+# Add custom aliases
+vim ~/.dotfiles/shared/aliases
+
+# Sync changes across machines
+git add -A && git commit -m "Custom aliases"
+git push
+```
+
+### Advanced Configuration
+```bash
+# Disable auto-sync
+dot sync off
+
+# Force profile re-detection
+dot profile detect
+
+# Check what packages would be installed
+dot packages
+
+# Reset to clean state
+dot reset
+```
+
+## 🤝 Contributing
+
+This system is designed to be easily extensible:
+
+1. **Add new packages**: Update `packages.yaml` and profile definitions
+2. **Create new profiles**: Add to `machine-profiles.yaml`
+3. **Extend functionality**: Add functions to `shared/functions`
+4. **Improve detection**: Enhance profile detection logic
+
+## 📚 Additional Resources
+
+- [Installation Guide](INSTALLATION.md)
+- [Configuration Reference](CONFIGURATION.md)
+- [Troubleshooting Guide](TROUBLESHOOTING.md)
+- [API Reference](API.md)
+
+---
+
+*This dotfiles system represents a modern approach to configuration management, balancing automation with flexibility, and efficiency with comprehensive functionality.*

docs/WEB_INSTALL_PAGE.html

@@ -0,0 +1,473 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Modern Dotfiles Management System - One-Line Install</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            background: linear-gradient(135deg, #0f1419 0%, #1a2332 100%);
+            color: #e6e6e6;
+            line-height: 1.6;
+            min-height: 100vh;
+        }
+        
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 2rem;
+        }
+        
+        .header {
+            text-align: center;
+            margin-bottom: 3rem;
+        }
+        
+        .title {
+            font-size: 2.5rem;
+            color: #64ffda;
+            margin-bottom: 1rem;
+            text-shadow: 0 0 20px rgba(100, 255, 218, 0.3);
+        }
+        
+        .subtitle {
+            font-size: 1.2rem;
+            color: #8892b0;
+            margin-bottom: 2rem;
+        }
+        
+        .install-section {
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(100, 255, 218, 0.2);
+            border-radius: 12px;
+            padding: 2rem;
+            margin: 2rem 0;
+            backdrop-filter: blur(10px);
+        }
+        
+        .install-title {
+            color: #64ffda;
+            font-size: 1.5rem;
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        
+        .install-code {
+            background: #0d1117;
+            border: 1px solid #30363d;
+            border-radius: 8px;
+            padding: 1.5rem;
+            margin: 1rem 0;
+            position: relative;
+            overflow-x: auto;
+        }
+        
+        .install-code code {
+            color: #e6e6e6;
+            font-size: 1.1rem;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            white-space: nowrap;
+        }
+        
+        .copy-button {
+            position: absolute;
+            top: 1rem;
+            right: 1rem;
+            background: #238636;
+            color: white;
+            border: none;
+            border-radius: 6px;
+            padding: 0.5rem 1rem;
+            cursor: pointer;
+            font-family: inherit;
+            font-size: 0.9rem;
+            transition: all 0.2s;
+        }
+        
+        .copy-button:hover {
+            background: #2ea043;
+            transform: translateY(-1px);
+        }
+        
+        .copy-button.copied {
+            background: #64ffda;
+            color: #0f1419;
+        }
+        
+        .features-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 2rem;
+            margin: 3rem 0;
+        }
+        
+        .feature-card {
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(139, 146, 176, 0.2);
+            border-radius: 8px;
+            padding: 1.5rem;
+            transition: transform 0.2s, border-color 0.2s;
+        }
+        
+        .feature-card:hover {
+            transform: translateY(-2px);
+            border-color: rgba(100, 255, 218, 0.4);
+        }
+        
+        .feature-title {
+            color: #64ffda;
+            font-size: 1.2rem;
+            margin-bottom: 0.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+        
+        .feature-description {
+            color: #8892b0;
+            font-size: 0.95rem;
+        }
+        
+        .profiles-section {
+            margin: 3rem 0;
+        }
+        
+        .profile-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 1.5rem;
+            margin-top: 2rem;
+        }
+        
+        .profile-card {
+            background: rgba(255, 255, 255, 0.03);
+            border: 1px solid rgba(139, 146, 176, 0.15);
+            border-radius: 8px;
+            padding: 1.5rem;
+        }
+        
+        .profile-name {
+            color: #ff6b6b;
+            font-weight: bold;
+            font-size: 1.1rem;
+            margin-bottom: 0.5rem;
+        }
+        
+        .profile-use-case {
+            color: #64ffda;
+            font-size: 0.9rem;
+            margin-bottom: 1rem;
+        }
+        
+        .profile-packages {
+            color: #8892b0;
+            font-size: 0.85rem;
+            line-height: 1.4;
+        }
+        
+        .quick-start {
+            background: linear-gradient(135deg, rgba(100, 255, 218, 0.1) 0%, rgba(255, 107, 107, 0.1) 100%);
+            border: 1px solid rgba(100, 255, 218, 0.3);
+            border-radius: 12px;
+            padding: 2rem;
+            margin: 3rem 0;
+        }
+        
+        .demo-steps {
+            margin: 2rem 0;
+        }
+        
+        .demo-step {
+            background: rgba(0, 0, 0, 0.3);
+            border-left: 4px solid #64ffda;
+            padding: 1rem;
+            margin: 1rem 0;
+            border-radius: 0 8px 8px 0;
+        }
+        
+        .demo-step-title {
+            color: #64ffda;
+            font-weight: bold;
+            margin-bottom: 0.5rem;
+        }
+        
+        .demo-step-command {
+            background: #0d1117;
+            padding: 0.5rem;
+            border-radius: 4px;
+            margin: 0.5rem 0;
+            font-family: monospace;
+            color: #e6e6e6;
+        }
+        
+        .emoji {
+            font-style: normal;
+        }
+        
+        .warning {
+            background: rgba(255, 193, 7, 0.1);
+            border: 1px solid rgba(255, 193, 7, 0.3);
+            border-radius: 8px;
+            padding: 1rem;
+            margin: 1rem 0;
+            color: #ffc107;
+        }
+        
+        @media (max-width: 768px) {
+            .container {
+                padding: 1rem;
+            }
+            
+            .title {
+                font-size: 2rem;
+            }
+            
+            .install-code code {
+                font-size: 1rem;
+            }
+            
+            .copy-button {
+                position: static;
+                margin-top: 1rem;
+                width: 100%;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1 class="title"><span class="emoji">🚀</span> Modern Dotfiles Management System</h1>
+            <p class="subtitle">Intelligent, adaptive terminal configuration that thinks for itself</p>
+        </div>
+
+        <div class="install-section">
+            <h2 class="install-title"><span class="emoji">⚡</span> One-Line Installation</h2>
+            <p style="margin-bottom: 1rem; color: #8892b0;">Copy and paste this command into your terminal:</p>
+            
+            <div class="install-code">
+                <code id="install-command">curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash</code>
+                <button class="copy-button" onclick="copyToClipboard('install-command', this)">Copy</button>
+            </div>
+            
+            <div class="warning">
+                <strong><span class="emoji">⚠️</span> Security Note:</strong> Always review scripts before running them. You can inspect the installer at: 
+                <a href="https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh" style="color: #64ffda;">install-web.sh</a>
+            </div>
+        </div>
+
+        <div class="quick-start">
+            <h2 class="install-title"><span class="emoji">🎯</span> What Happens Next</h2>
+            <div class="demo-steps">
+                <div class="demo-step">
+                    <div class="demo-step-title">1. <span class="emoji">🔍</span> Auto-Detection</div>
+                    <p>System analyzes your machine and suggests the best profile (server, dev, personal, etc.)</p>
+                </div>
+                <div class="demo-step">
+                    <div class="demo-step-title">2. <span class="emoji">📦</span> Smart Installation</div>
+                    <p>Installs only the packages you need based on your machine type</p>
+                </div>
+                <div class="demo-step">
+                    <div class="demo-step-title">3. <span class="emoji">🔗</span> Configuration</div>
+                    <p>Sets up universal aliases and shortcuts that work everywhere</p>
+                </div>
+                <div class="demo-step">
+                    <div class="demo-step-title">4. <span class="emoji">✅</span> Ready to Use</div>
+                    <p>Restart your shell and enjoy your new supercharged terminal</p>
+                </div>
+            </div>
+        </div>
+
+        <div class="profiles-section">
+            <h2 class="install-title"><span class="emoji">🤖</span> Adaptive Machine Profiles</h2>
+            <p style="margin-bottom: 2rem; color: #8892b0;">The system automatically detects your machine type and installs appropriate tools:</p>
+            
+            <div class="profile-grid">
+                <div class="profile-card">
+                    <div class="profile-name"><span class="emoji">🖥️</span> Server</div>
+                    <div class="profile-use-case">Production servers, minimal VMs</div>
+                    <div class="profile-packages">
+                        <strong>Packages:</strong> curl, git, vim, sshuttle, ripgrep, fd<br>
+                        <strong>Perfect for:</strong> System administration, log analysis
+                    </div>
+                </div>
+                
+                <div class="profile-card">
+                    <div class="profile-name"><span class="emoji">💻</span> Development</div>
+                    <div class="profile-use-case">Full development machines</div>
+                    <div class="profile-packages">
+                        <strong>Packages:</strong> All tools + Claude AI, Gemini CLI, Docker, modern CLI tools<br>
+                        <strong>Perfect for:</strong> Primary development workstations
+                    </div>
+                </div>
+                
+                <div class="profile-card">
+                    <div class="profile-name"><span class="emoji">⚡</span> Dev-Lite</div>
+                    <div class="profile-use-case">Lightweight development</div>
+                    <div class="profile-packages">
+                        <strong>Packages:</strong> Development tools without heavy packages<br>
+                        <strong>Perfect for:</strong> Cloud VMs, resource-constrained machines
+                    </div>
+                </div>
+                
+                <div class="profile-card">
+                    <div class="profile-name"><span class="emoji">🏠</span> Personal</div>
+                    <div class="profile-use-case">Personal machines</div>
+                    <div class="profile-packages">
+                        <strong>Packages:</strong> Everything + personal productivity tools<br>
+                        <strong>Perfect for:</strong> Personal laptops, home workstations
+                    </div>
+                </div>
+                
+                <div class="profile-card">
+                    <div class="profile-name"><span class="emoji">🔧</span> Minimal</div>
+                    <div class="profile-use-case">Bare essentials</div>
+                    <div class="profile-packages">
+                        <strong>Packages:</strong> curl, git, vim only<br>
+                        <strong>Perfect for:</strong> Emergency access, extremely limited environments
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div class="features-grid">
+            <div class="feature-card">
+                <div class="feature-title"><span class="emoji">🎯</span> Smart Package Management</div>
+                <div class="feature-description">
+                    Automatically installs packages from npm, GitHub releases, and system repositories. 
+                    Only installs what you need based on your machine type.
+                </div>
+            </div>
+            
+            <div class="feature-card">
+                <div class="feature-title"><span class="emoji">🔄</span> Intelligent Sync</div>
+                <div class="feature-description">
+                    Daily auto-sync with rate limiting. Updates only when needed, runs in background 
+                    to avoid blocking terminal startup.
+                </div>
+            </div>
+            
+            <div class="feature-card">
+                <div class="feature-title"><span class="emoji">⚡</span> Fast Updates</div>
+                <div class="feature-description">
+                    Efficient update checking (2-5 seconds) vs traditional npm update (30-60 seconds). 
+                    Only updates packages that actually need it.
+                </div>
+            </div>
+            
+            <div class="feature-card">
+                <div class="feature-title"><span class="emoji">🌍</span> Universal Shortcuts</div>
+                <div class="feature-description">
+                    Same aliases and shortcuts work on all machines. Navigate, manage files, 
+                    and use git with consistent commands everywhere.
+                </div>
+            </div>
+            
+            <div class="feature-card">
+                <div class="feature-title"><span class="emoji">🛡️</span> Safe Reset</div>
+                <div class="feature-description">
+                    Complete reset capability back to vanilla state. Multiple reset levels 
+                    with automatic backups for peace of mind.
+                </div>
+            </div>
+            
+            <div class="feature-card">
+                <div class="feature-title"><span class="emoji">🔧</span> Cross-Platform</div>
+                <div class="feature-description">
+                    Works on Linux (Ubuntu, CentOS, Debian), macOS, and WSL. 
+                    Automatically detects OS and uses appropriate package managers.
+                </div>
+            </div>
+        </div>
+
+        <div class="install-section">
+            <h2 class="install-title"><span class="emoji">🎮</span> Quick Commands You'll Love</h2>
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 1rem; margin-top: 1rem;">
+                <div>
+                    <h4 style="color: #64ffda; margin-bottom: 0.5rem;">Universal Navigation</h4>
+                    <div class="demo-step-command">l              # Enhanced ls -lah</div>
+                    <div class="demo-step-command">..             # cd ..</div>
+                    <div class="demo-step-command">...            # cd ../..</div>
+                </div>
+                <div>
+                    <h4 style="color: #64ffda; margin-bottom: 0.5rem;">Git Shortcuts</h4>
+                    <div class="demo-step-command">g              # git</div>
+                    <div class="demo-step-command">gs             # git status</div>
+                    <div class="demo-step-command">ga             # git add</div>
+                </div>
+                <div>
+                    <h4 style="color: #64ffda; margin-bottom: 0.5rem;">System Management</h4>
+                    <div class="demo-step-command">dotstatus      # Show system status</div>
+                    <div class="demo-step-command">dotupdate      # Update packages</div>
+                    <div class="demo-step-command">dotprofile     # Show machine profile</div>
+                </div>
+                <div>
+                    <h4 style="color: #64ffda; margin-bottom: 0.5rem;">Development Tools</h4>
+                    <div class="demo-step-command">claude         # Claude AI CLI</div>
+                    <div class="demo-step-command">tm             # Task Master</div>
+                    <div class="demo-step-command">ports          # Show open ports</div>
+                </div>
+            </div>
+        </div>
+
+        <div class="install-section">
+            <h2 class="install-title"><span class="emoji">🚀</span> Ready to Get Started?</h2>
+            <p style="margin-bottom: 1rem; color: #8892b0;">Copy the command above and paste it into your terminal. Installation takes about 30 seconds.</p>
+            
+            <div class="install-code">
+                <code id="install-command-2">curl -fsSL https://raw.git.turnersrus.com/razzam21/dotfiles/dev/install-web.sh | bash</code>
+                <button class="copy-button" onclick="copyToClipboard('install-command-2', this)">Copy</button>
+            </div>
+            
+            <p style="margin-top: 1rem; color: #8892b0; font-size: 0.9rem;">
+                <span class="emoji">📚</span> <strong>Want to learn more first?</strong> 
+                Check out the <a href="https://git.turnersrus.com/razzam21/dotfiles" style="color: #64ffda;">Git repository</a> 
+                for full documentation and source code.
+            </p>
+        </div>
+    </div>
+
+    <script>
+        function copyToClipboard(elementId, button) {
+            const element = document.getElementById(elementId);
+            const text = element.textContent;
+            
+            navigator.clipboard.writeText(text).then(function() {
+                button.textContent = 'Copied!';
+                button.classList.add('copied');
+                
+                setTimeout(function() {
+                    button.textContent = 'Copy';
+                    button.classList.remove('copied');
+                }, 2000);
+            }, function(err) {
+                console.error('Could not copy text: ', err);
+                // Fallback for older browsers
+                const textarea = document.createElement('textarea');
+                textarea.value = text;
+                document.body.appendChild(textarea);
+                textarea.select();
+                document.execCommand('copy');
+                document.body.removeChild(textarea);
+                
+                button.textContent = 'Copied!';
+                button.classList.add('copied');
+                
+                setTimeout(function() {
+                    button.textContent = 'Copy';
+                    button.classList.remove('copied');
+                }, 2000);
+            });
+        }
+    </script>
+</body>
+</html>

install-web.sh

@@ -13,9 +13,9 @@ CYAN='\033[0;36m'
 NC='\033[0m' # No Color
 
 # Configuration
-REPO_URL="https://github.com/your-username/dotfiles"
+REPO_URL="https://git.turnersrus.com/razzam21/dotfiles"
 DOTFILES_DIR="$HOME/.dotfiles"
-BRANCH="main"
+BRANCH="dev"
 
 # Function to print colored output
 print_color() {

shared/aliases

@@ -0,0 +1,82 @@
+# Shared Aliases
+# Compatible with both bash and zsh
+
+# Navigation
+alias ..='cd ..'
+alias ...='cd ../..'
+alias ....='cd ../../..'
+alias ~='cd ~'
+alias -- -='cd -'
+
+# List files
+alias l='ls -lah'
+alias la='ls -la'
+alias ll='ls -l'
+alias ls='ls --color=auto'
+
+# Grep with color
+alias grep='grep --color=auto'
+alias fgrep='fgrep --color=auto'
+alias egrep='egrep --color=auto'
+
+# Safety nets
+alias rm='rm -i'
+alias cp='cp -i'
+alias mv='mv -i'
+
+# Git shortcuts
+alias g='git'
+alias ga='git add'
+alias gc='git commit'
+alias gp='git push'
+alias gl='git pull'
+alias gs='git status'
+alias gd='git diff'
+alias gb='git branch'
+alias gco='git checkout'
+
+# System monitoring
+alias df='df -h'
+alias du='du -h'
+alias free='free -h'
+alias ps='ps aux'
+
+# Network
+alias ping='ping -c 5'
+alias ports='netstat -tuln'
+
+# Package management (Debian/Ubuntu)
+alias apt-update='sudo apt update && sudo apt upgrade'
+alias apt-install='sudo apt install'
+alias apt-search='sudo apt search'
+
+# Quick edits
+alias bashrc='$EDITOR ~/.bashrc'
+alias zshrc='$EDITOR ~/.zshrc'
+alias vimrc='$EDITOR ~/.vimrc'
+
+# Utilities
+alias weather='curl wttr.in'
+alias myip='curl ifconfig.me'
+alias path='echo $PATH | tr ":" "\n"'
+alias reload='exec $SHELL'
+
+# Modern Dotfiles Management - Unified Command Interface
+alias dot='$HOME/.dotfiles/shared/dot-command'
+
+# Task Master aliases
+alias tm='task-master'
+alias taskmaster='task-master'
+
+# SSH tunnel aliases
+alias sshuttle-vpn='sudo sshuttle -e "ssh -F /home/eric/.ssh/config" -NH'
+alias sshuttle-txtwire='sshuttle-vpn -r root@208.76.194.2 192.168.0.0/21'
+
+# Project control alias
+alias ta="/home/eric/projects/misc/terraform/projectctl.sh"
+
+# Git remote URL conversion aliases
+alias git-remote-toggle='git_remote_toggle'
+alias git-remote-ssh='git_remote_to_ssh'
+alias git-remote-https='git_remote_to_https'
+alias git-convert='git_remote_convert'

shared/completions

@@ -0,0 +1,83 @@
+# Shared Completion Functions
+# Compatible with both bash and zsh
+
+# Custom completion for 'ta' command
+_ta_complete() {
+  local cur prev actions layers tf_cmds ansible_cmds
+  
+  # Get current word and previous word based on shell
+  if [[ -n "$ZSH_VERSION" ]]; then
+    # Zsh completion
+    cur="${words[CURRENT]}"
+    prev="${words[CURRENT-1]}"
+    local comp_word=$CURRENT
+  else
+    # Bash completion
+    local cur prev
+    _get_comp_words_by_ref cur prev
+    local comp_word=$COMP_CWORD
+  fi
+  
+  actions="terraform ansible install remove"
+  layers="foundation showcase"
+  tf_cmds="init plan apply refresh destroy"
+  ansible_cmds=""  # Add Ansible-specific commands here if needed
+
+  case $comp_word in
+    1)
+      if [[ -n "$ZSH_VERSION" ]]; then
+        compadd $actions
+      else
+        COMPREPLY=( $(compgen -W "$actions" -- "$cur") )
+      fi
+      ;;
+    2)
+      if [[ "$prev" == "terraform" || "$prev" == "ansible" ]]; then
+        if [[ -n "$ZSH_VERSION" ]]; then
+          compadd $layers
+        else
+          COMPREPLY=( $(compgen -W "$layers" -- "$cur") )
+        fi
+      fi
+      ;;
+    3)
+      if [[ -n "$ZSH_VERSION" ]]; then
+        local first_word="${words[2]}"
+      else
+        local first_word="${COMP_WORDS[1]}"
+      fi
+      
+      if [[ "$first_word" == "terraform" ]]; then
+        if [[ -n "$ZSH_VERSION" ]]; then
+          compadd $tf_cmds
+        else
+          COMPREPLY=( $(compgen -W "$tf_cmds" -- "$cur") )
+        fi
+      elif [[ "$first_word" == "ansible" ]]; then
+        if [[ -n "$ZSH_VERSION" ]]; then
+          compadd $ansible_cmds
+        else
+          COMPREPLY=( $(compgen -W "$ansible_cmds" -- "$cur") )
+        fi
+      fi
+      ;;
+    *)
+      # Fallback to file completions
+      if [[ -n "$ZSH_VERSION" ]]; then
+        _files
+      else
+        COMPREPLY=( $(compgen -f -- "$cur") )
+      fi
+      ;;
+  esac
+  return 0
+}
+
+# Register completion based on shell
+if [[ -n "$ZSH_VERSION" ]]; then
+  # Zsh completion registration
+  compdef _ta_complete ta
+else
+  # Bash completion registration
+  complete -F _ta_complete ta
+fi

shared/dot-command

@@ -0,0 +1,204 @@
+#!/bin/bash
+# Modern Dotfiles Management System - Unified Command Interface
+# Usage: dot <action> [subaction] [flags]
+
+# Source required functions
+DOTFILES_DIR="$HOME/.dotfiles"
+if [[ -f "$DOTFILES_DIR/shared/functions" ]]; then
+    source "$DOTFILES_DIR/shared/functions"
+fi
+if [[ -f "$DOTFILES_DIR/shared/sync" ]]; then
+    source "$DOTFILES_DIR/shared/sync"
+fi
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_color() {
+    local color=$1
+    local message=$2
+    echo -e "${color}${message}${NC}"
+}
+
+# Function to show help
+show_help() {
+    print_color "$CYAN" "Modern Dotfiles Management System"
+    echo ""
+    print_color "$YELLOW" "Usage: dot <action> [subaction] [flags]"
+    echo ""
+    print_color "$BLUE" "SYNC MANAGEMENT:"
+    echo "  dot sync [--force]          Sync dotfiles with remote repository"
+    echo "  dot sync status             Show sync status and last update"
+    echo "  dot sync on                 Enable automatic syncing"
+    echo "  dot sync off                Disable automatic syncing"
+    echo ""
+    print_color "$BLUE" "PACKAGE MANAGEMENT:"
+    echo "  dot packages [list]         Show package status for current profile"
+    echo "  dot packages install        Install all packages for current profile"
+    echo "  dot packages check          Check package installation status"
+    echo "  dot packages update         Install pending updates"
+    echo "  dot packages status         Show update status"
+    echo "  dot packages check-updates  Check for package updates (fast)"
+    echo ""
+    print_color "$BLUE" "PROFILE MANAGEMENT:"
+    echo "  dot profile [show]          Show current machine profile"
+    echo "  dot profile set <name>      Switch to specified profile"
+    echo "  dot profile detect          Re-detect machine type"
+    echo ""
+    print_color "$BLUE" "RESET OPERATIONS:"
+    echo "  dot reset                   Interactive reset menu"
+    echo "  dot reset --soft            Remove configs, restore originals"
+    echo "  dot reset --hard            Soft reset + uninstall packages"
+    echo "  dot reset --nuclear         Complete removal (back to vanilla)"
+    echo ""
+    print_color "$BLUE" "GENERAL:"
+    echo "  dot help                    Show this help message"
+    echo "  dot version                 Show version information"
+    echo ""
+    print_color "$GREEN" "Examples:"
+    echo "  dot sync --force            Force sync now"
+    echo "  dot profile set dev         Switch to development profile"
+    echo "  dot packages update         Update all packages"
+    echo "  dot reset --soft            Safely reset configurations"
+}
+
+# Function to show version
+show_version() {
+    print_color "$CYAN" "Modern Dotfiles Management System"
+    print_color "$YELLOW" "Version: 1.0.0"
+    print_color "$GREEN" "Repository: https://git.turnersrus.com/razzam21/dotfiles"
+}
+
+# Main command router
+main() {
+    local action="$1"
+    local subaction="$2"
+    local flag="$3"
+    
+    case "$action" in
+        "sync")
+            case "$subaction" in
+                "status")
+                    dotfiles_sync_status
+                    ;;
+                "on")
+                    dotfiles_sync_enable
+                    ;;
+                "off")
+                    dotfiles_sync_disable
+                    ;;
+                "--force"|"force")
+                    dotfiles_sync_force
+                    ;;
+                "")
+                    if [[ "$flag" == "--force" ]]; then
+                        dotfiles_sync_force
+                    else
+                        dotfiles_sync_now
+                    fi
+                    ;;
+                *)
+                    print_color "$RED" "Error: Unknown sync subaction '$subaction'"
+                    echo "Use 'dot help' for available commands"
+                    return 1
+                    ;;
+            esac
+            ;;
+        "packages"|"pkg")
+            case "$subaction" in
+                "list"|"")
+                    dotfiles_packages_status
+                    ;;
+                "install")
+                    dotfiles_install_packages
+                    ;;
+                "check")
+                    dotfiles_check_packages
+                    ;;
+                "update")
+                    dotfiles_update_install
+                    ;;
+                "status")
+                    dotfiles_update_status
+                    ;;
+                "check-updates")
+                    dotfiles_update_check
+                    ;;
+                *)
+                    print_color "$RED" "Error: Unknown packages subaction '$subaction'"
+                    echo "Use 'dot help' for available commands"
+                    return 1
+                    ;;
+            esac
+            ;;
+        "profile")
+            case "$subaction" in
+                "show"|"")
+                    dotfiles_profile_status
+                    ;;
+                "set")
+                    if [[ -z "$flag" ]]; then
+                        print_color "$RED" "Error: Profile name required"
+                        echo "Usage: dot profile set <profile_name>"
+                        return 1
+                    fi
+                    dotfiles_profile_set "$flag"
+                    ;;
+                "detect")
+                    dotfiles_profile_detect
+                    ;;
+                *)
+                    print_color "$RED" "Error: Unknown profile subaction '$subaction'"
+                    echo "Use 'dot help' for available commands"
+                    return 1
+                    ;;
+            esac
+            ;;
+        "reset")
+            case "$subaction" in
+                "--soft"|"soft")
+                    "$HOME/.dotfiles/reset.sh" --soft
+                    ;;
+                "--hard"|"hard")
+                    "$HOME/.dotfiles/reset.sh" --hard
+                    ;;
+                "--nuclear"|"nuclear")
+                    "$HOME/.dotfiles/reset.sh" --nuclear
+                    ;;
+                "")
+                    "$HOME/.dotfiles/reset.sh"
+                    ;;
+                *)
+                    print_color "$RED" "Error: Unknown reset option '$subaction'"
+                    echo "Available options: --soft, --hard, --nuclear"
+                    return 1
+                    ;;
+            esac
+            ;;
+        "help"|"-h"|"--help")
+            show_help
+            ;;
+        "version"|"-v"|"--version")
+            show_version
+            ;;
+        "")
+            print_color "$RED" "Error: No action specified"
+            echo "Use 'dot help' for available commands"
+            return 1
+            ;;
+        *)
+            print_color "$RED" "Error: Unknown action '$action'"
+            echo "Use 'dot help' for available commands"
+            return 1
+            ;;
+    esac
+}
+
+# Execute main function with all arguments
+main "$@"

shared/exports

@@ -0,0 +1,34 @@
+# Environment Variables
+# Shared across all shells
+
+# Editor preferences
+export EDITOR=vim
+export VISUAL=vim
+export PAGER=less
+
+# Path modifications
+export PATH="$HOME/.local/bin:$HOME/bin:/usr/local/bin:$PATH"
+export PATH="~/.npm-global/bin:$PATH"
+export PATH="/home/eric/.opencode/bin:$PATH"
+
+# History settings
+export HISTSIZE=10000
+export HISTFILESIZE=20000
+export HISTCONTROL=ignoreboth:erasedups
+
+# Color support
+export CLICOLOR=1
+export LSCOLORS=ExFxBxDxCxegedabagacad
+
+# Less configuration
+export LESS='-R -i -M -F -X'
+
+# Locale settings
+export LC_ALL=en_US.UTF-8
+export LANG=en_US.UTF-8
+
+# Development tools
+export GREP_OPTIONS='--color=auto'
+
+# Custom environment variables
+export LOCAL_ENDPOINT=http://10.13.0.254:11434/v1

shared/functions

@@ -0,0 +1,310 @@
+# Shared Functions
+# Compatible with both bash and zsh
+
+# Create directory and cd into it
+mkcd() {
+    mkdir -p "$1" && cd "$1"
+}
+
+# Extract archives
+extract() {
+    if [ -f "$1" ]; then
+        case "$1" in
+            *.tar.bz2)   tar xjf "$1"     ;;
+            *.tar.gz)    tar xzf "$1"     ;;
+            *.bz2)       bunzip2 "$1"     ;;
+            *.rar)       unrar x "$1"     ;;
+            *.gz)        gunzip "$1"      ;;
+            *.tar)       tar xf "$1"      ;;
+            *.tbz2)      tar xjf "$1"     ;;
+            *.tgz)       tar xzf "$1"     ;;
+            *.zip)       unzip "$1"       ;;
+            *.Z)         uncompress "$1"  ;;
+            *.7z)        7z x "$1"        ;;
+            *)           echo "'$1' cannot be extracted via extract()" ;;
+        esac
+    else
+        echo "'$1' is not a valid file"
+    fi
+}
+
+# Find files by name
+findfile() {
+    find . -type f -name "*$1*" 2>/dev/null
+}
+
+# Find directories by name
+finddir() {
+    find . -type d -name "*$1*" 2>/dev/null
+}
+
+# Process grep
+psgrep() {
+    ps aux | grep "$1" | grep -v grep
+}
+
+# Quick backup
+backup() {
+    cp "$1"{,.bak}
+}
+
+# Show disk usage of current directory
+usage() {
+    du -sh ./* | sort -hr
+}
+
+# Package management functions
+dotfiles_packages_status() {
+    echo "📦 Package Status Check"
+    echo "======================"
+    
+    # Check if package manager is available
+    if [[ -f "$HOME/.dotfiles/lib/package_manager.sh" ]]; then
+        source "$HOME/.dotfiles/lib/package_manager.sh"
+        
+        echo "📋 System packages:"
+        for pkg in sshuttle curl git vim; do
+            case "$pkg" in
+                "sshuttle") check="which sshuttle" ;;
+                "curl") check="which curl" ;;
+                "git") check="which git" ;;
+                "vim") check="which vim" ;;
+            esac
+            if is_package_installed "$check"; then
+                echo "  ✅ $pkg"
+            else
+                echo "  ❌ $pkg (missing)"
+            fi
+        done
+        
+        echo ""
+        echo "⚡ Binary packages:"
+        for pkg in claude-code gemini-cli; do
+            case "$pkg" in
+                "claude-code") check="which claude" ;;
+                "gemini-cli") check="which gemini" ;;
+            esac
+            if is_package_installed "$check"; then
+                echo "  ✅ $pkg"
+            else
+                echo "  ❌ $pkg (missing)"
+            fi
+        done
+        
+        echo ""
+        echo "🐙 GitHub packages:"
+        for pkg in fzf bat ripgrep fd delta; do
+            case "$pkg" in
+                "fzf") check="which fzf" ;;
+                "bat") check="which bat" ;;
+                "ripgrep") check="which rg" ;;
+                "fd") check="which fd" ;;
+                "delta") check="which delta" ;;
+            esac
+            if is_package_installed "$check"; then
+                echo "  ✅ $pkg"
+            else
+                echo "  ❌ $pkg (missing)"
+            fi
+        done
+        
+    else
+        echo "❌ Package manager not available"
+    fi
+}
+
+dotfiles_install_packages() {
+    if [[ -f "$HOME/.dotfiles/lib/package_manager.sh" ]]; then
+        source "$HOME/.dotfiles/lib/package_manager.sh"
+        install_all_packages
+    else
+        echo "❌ Package manager not available"
+    fi
+}
+
+dotfiles_check_packages() {
+    if [[ -f "$HOME/.dotfiles/lib/package_manager.sh" ]]; then
+        source "$HOME/.dotfiles/lib/package_manager.sh"
+        install_all_packages true  # Skip optional packages
+    else
+        echo "❌ Package manager not available"
+    fi
+}
+
+# Profile management functions
+dotfiles_profile_status() {
+    if [[ -f "$HOME/.dotfiles/lib/profile_manager.sh" ]]; then
+        source "$HOME/.dotfiles/lib/profile_manager.sh"
+        show_profile_status
+    else
+        echo "❌ Profile manager not available"
+    fi
+}
+
+dotfiles_profile_set() {
+    local new_profile="$1"
+    if [[ -z "$new_profile" ]]; then
+        echo "Usage: dotfiles_profile_set <profile>"
+        echo "Available profiles: server, dev, dev-lite, personal, minimal"
+        return 1
+    fi
+    
+    if [[ -f "$HOME/.dotfiles/lib/profile_manager.sh" ]]; then
+        source "$HOME/.dotfiles/lib/profile_manager.sh"
+        set_profile "$new_profile"
+        echo "✅ Profile set to: $new_profile"
+        echo "🔄 Run 'dotinstall' to apply profile changes"
+    else
+        echo "❌ Profile manager not available"
+    fi
+}
+
+dotfiles_profile_detect() {
+    if [[ -f "$HOME/.dotfiles/lib/profile_manager.sh" ]]; then
+        source "$HOME/.dotfiles/lib/profile_manager.sh"
+        local detected=$(detect_machine_profile)
+        echo "🤖 Auto-detected profile: $detected"
+        echo "Current profile: $(get_current_profile)"
+        echo ""
+        echo "Set detected profile? [y/N]: "
+        read -r response
+        if [[ "$response" =~ ^[Yy]$ ]]; then
+            set_profile "$detected"
+            echo "✅ Profile updated to: $detected"
+        fi
+    else
+        echo "❌ Profile manager not available"
+    fi
+}
+
+# Update management functions
+dotfiles_update_check() {
+    local force=${1:-false}
+    if [[ "$1" == "--force" ]]; then
+        force=true
+    fi
+    
+    if [[ -f "$HOME/.dotfiles/lib/update_checker.sh" ]]; then
+        source "$HOME/.dotfiles/lib/update_checker.sh"
+        check_for_updates "$force" true
+    else
+        echo "❌ Update checker not available"
+    fi
+}
+
+dotfiles_update_status() {
+    if [[ -f "$HOME/.dotfiles/lib/update_checker.sh" ]]; then
+        source "$HOME/.dotfiles/lib/update_checker.sh"
+        show_update_status
+    else
+        echo "❌ Update checker not available"
+    fi
+}
+
+dotfiles_update_install() {
+    if [[ -f "$HOME/.dotfiles/lib/update_checker.sh" ]]; then
+        source "$HOME/.dotfiles/lib/update_checker.sh"
+        update_packages
+    else
+        echo "❌ Update checker not available"
+    fi
+}
+
+# Git remote URL conversion functions
+git_remote_convert() {
+    local remote_name="${1:-origin}"
+    local target_format="$2"
+    
+    # Get current remote URL
+    local current_url=$(git remote get-url "$remote_name" 2>/dev/null)
+    
+    if [[ -z "$current_url" ]]; then
+        echo "❌ No remote '$remote_name' found in this repository"
+        return 1
+    fi
+    
+    local new_url=""
+    local current_format=""
+    
+    # Detect current format and convert
+    if [[ "$current_url" =~ ^git@([^:]+):(.+)\.git$ ]]; then
+        # SSH format: git@hostname:user/repo.git
+        current_format="ssh"
+        local hostname="${BASH_REMATCH[1]}"
+        local repo_path="${BASH_REMATCH[2]}"
+        new_url="https://${hostname}/${repo_path}.git"
+    elif [[ "$current_url" =~ ^https://([^/]+)/(.+)\.git$ ]]; then
+        # HTTPS format: https://hostname/user/repo.git
+        current_format="https"
+        local hostname="${BASH_REMATCH[1]}"
+        local repo_path="${BASH_REMATCH[2]}"
+        new_url="git@${hostname}:${repo_path}.git"
+    elif [[ "$current_url" =~ ^https://([^/]+)/(.+)$ ]]; then
+        # HTTPS format without .git suffix
+        current_format="https"
+        local hostname="${BASH_REMATCH[1]}"
+        local repo_path="${BASH_REMATCH[2]}"
+        new_url="git@${hostname}:${repo_path}.git"
+    else
+        echo "❌ Unknown URL format: $current_url"
+        return 1
+    fi
+    
+    # Check if target format is specified and matches current
+    if [[ -n "$target_format" ]]; then
+        if [[ "$target_format" == "$current_format" ]]; then
+            echo "✅ Remote '$remote_name' is already in $current_format format"
+            echo "   Current URL: $current_url"
+            return 0
+        elif [[ "$target_format" != "ssh" && "$target_format" != "https" ]]; then
+            echo "❌ Invalid target format. Use 'ssh' or 'https'"
+            return 1
+        fi
+        
+        # Convert to specific format
+        if [[ "$target_format" == "ssh" && "$current_format" == "https" ]]; then
+            # Already converted above
+            :
+        elif [[ "$target_format" == "https" && "$current_format" == "ssh" ]]; then
+            # Already converted above
+            :
+        fi
+    fi
+    
+    # Show current and new URLs
+    echo "🔄 Converting git remote '$remote_name'"
+    echo "   From ($current_format): $current_url"
+    echo "   To   ($([[ $current_format == "ssh" ]] && echo "https" || echo "ssh")): $new_url"
+    echo ""
+    
+    # Confirm change
+    echo "Proceed with conversion? [y/N]: "
+    read -r response
+    if [[ "$response" =~ ^[Yy]$ ]]; then
+        if git remote set-url "$remote_name" "$new_url"; then
+            echo "✅ Successfully converted remote '$remote_name'"
+            echo "   New URL: $(git remote get-url "$remote_name")"
+        else
+            echo "❌ Failed to update remote URL"
+            return 1
+        fi
+    else
+        echo "❌ Conversion cancelled"
+        return 1
+    fi
+}
+
+git_remote_to_ssh() {
+    local remote_name="${1:-origin}"
+    git_remote_convert "$remote_name" "ssh"
+}
+
+git_remote_to_https() {
+    local remote_name="${1:-origin}"
+    git_remote_convert "$remote_name" "https"
+}
+
+git_remote_toggle() {
+    local remote_name="${1:-origin}"
+    git_remote_convert "$remote_name"
+}

shared/prompt

@@ -0,0 +1,25 @@
+# Shared Prompt Configuration
+# Set up a consistent prompt across shells
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+BLUE='\033[0;34m'
+PURPLE='\033[0;35m'
+CYAN='\033[0;36m'
+WHITE='\033[0;37m'
+RESET='\033[0m'
+
+# Git branch display function
+git_branch() {
+    git branch 2>/dev/null | grep '^*' | colrm 1 2
+}
+
+# Git status indicators
+git_status() {
+    local status=$(git status --porcelain 2>/dev/null)
+    if [[ -n $status ]]; then
+        echo "*"
+    fi
+}

shared/sync

@@ -0,0 +1,84 @@
+# Dotfiles Auto-Sync Configuration
+# This file is sourced by shell configurations to enable automatic syncing
+
+# Function to run dotfiles sync
+dotfiles_sync() {
+    if [[ -x "$HOME/.dotfiles/sync.sh" ]]; then
+        "$HOME/.dotfiles/sync.sh" --background
+    fi
+}
+
+# Function to enable/disable sync
+dotfiles_sync_enable() {
+    echo "true" > "$HOME/.dotfiles/.sync_enabled"
+    echo "✅ Dotfiles auto-sync enabled"
+}
+
+dotfiles_sync_disable() {
+    echo "false" > "$HOME/.dotfiles/.sync_enabled"
+    echo "❌ Dotfiles auto-sync disabled"
+}
+
+# Function to manually trigger sync
+dotfiles_sync_now() {
+    if [[ -x "$HOME/.dotfiles/sync.sh" ]]; then
+        "$HOME/.dotfiles/sync.sh" --manual
+    else
+        echo "❌ Sync script not found or not executable"
+    fi
+}
+
+# Function to force sync (ignores timing)
+dotfiles_sync_force() {
+    if [[ -x "$HOME/.dotfiles/sync.sh" ]]; then
+        "$HOME/.dotfiles/sync.sh" --force
+    else
+        echo "❌ Sync script not found or not executable"
+    fi
+}
+
+# Function to show sync status
+dotfiles_sync_status() {
+    local sync_enabled_file="$HOME/.dotfiles/.sync_enabled"
+    local last_sync_file="$HOME/.dotfiles/.last_sync"
+    local sync_log="$HOME/.dotfiles/.sync.log"
+    
+    echo "🔧 Dotfiles Sync Status:"
+    
+    if [[ -f "$sync_enabled_file" ]]; then
+        local enabled=$(cat "$sync_enabled_file")
+        if [[ "$enabled" == "true" ]]; then
+            echo "   Status: ✅ Enabled"
+        else
+            echo "   Status: ❌ Disabled"
+        fi
+    else
+        echo "   Status: ✅ Enabled (default)"
+    fi
+    
+    if [[ -f "$last_sync_file" ]]; then
+        local last_sync=$(cat "$last_sync_file")
+        local last_sync_date=$(date -d "@$last_sync" 2>/dev/null || echo "Unknown")
+        echo "   Last sync: $last_sync_date"
+    else
+        echo "   Last sync: Never"
+    fi
+    
+    if [[ -f "$sync_log" ]]; then
+        echo "   Recent activity:"
+        tail -3 "$sync_log" | sed 's/^/     /'
+    fi
+}
+
+# Auto-sync on shell startup (only for interactive shells)
+if [[ $- == *i* ]] && [[ -n "$HOME" ]] && [[ -d "$HOME/.dotfiles" ]]; then
+    dotfiles_sync
+    
+    # Also check for updates periodically (background, no output)
+    if [[ -f "$HOME/.dotfiles/lib/update_checker.sh" ]]; then
+        (
+            source "$HOME/.dotfiles/lib/update_checker.sh"
+            check_for_updates false false >/dev/null 2>&1 &
+        )
+    fi
+fi

vim/.vimrc

@@ -0,0 +1,55 @@
+" Basic Vim Configuration
+
+" Enable syntax highlighting
+syntax on
+
+" Show line numbers
+set number
+
+" Enable mouse support
+set mouse=a
+
+" Set tab width
+set tabstop=4
+set shiftwidth=4
+set expandtab
+
+" Enable auto-indentation
+set autoindent
+set smartindent
+
+" Show matching brackets
+set showmatch
+
+" Enable incremental search
+set incsearch
+set hlsearch
+
+" Case insensitive search
+set ignorecase
+set smartcase
+
+" Show command in status line
+set showcmd
+
+" Enable file type detection
+filetype on
+filetype plugin on
+filetype indent on
+
+" Set encoding
+set encoding=utf-8
+
+" Better backspace behavior
+set backspace=indent,eol,start
+
+" Enable line wrapping
+set wrap
+set linebreak
+
+" Show ruler
+set ruler
+
+" Status line
+set laststatus=2
+set statusline=%F%m%r%h%w\ [%{&ff}]\ [%Y]\ [POS=%l,%v][%p%%]\ [LEN=%L]