feat: add generic tmux-based dev environment commands

Add /start-local for web development:
- Auto-detects project types (Next.js, Vite, Django, Flask, etc.)
- Environment file mapping (staging → .env.staging)
- Random port assignment to prevent conflicts
- Multi-window tmux layout (servers, logs, work, git)
- Session metadata tracking

Add /start-ios for iOS development:
- Supports React Native, Capacitor, Native iOS
- Auto-detects project structure
- Poltergeist integration for auto-rebuild
- Simulator management and log streaming
- Build configuration mapping (Debug → .env.development)

Add /start-android for Android development:
- Supports React Native, Capacitor, Flutter, Native Android
- Emulator management with port forwarding
- Poltergeist integration for auto-rebuild
- Build variant mapping (staging → .env.staging)
- Multi-window tmux layout with logcat

All commands are generic and work across any project.

Author: stevengonsalvez

claude-code-4.5/commands/start-android.md

@@ -0,0 +1,221 @@
+# /start-android - Start Android Development Environment in tmux
+
+Start Android development with Emulator, dev server, and optional Poltergeist auto-rebuild.
+
+## Usage
+
+```bash
+/start-android                # debug build, .env.development
+/start-android staging        # staging build, .env.staging
+/start-android release        # release build, .env.production
+/start-android debug Pixel_7  # Specific emulator
+```
+
+## Process
+
+### Step 1: Determine Build Variant
+
+```bash
+VARIANT=${1:-debug}
+DEVICE=${2:-"Pixel_7_Pro"}
+
+case $VARIANT in
+    debug)
+        ENV_FILE=".env.development"
+        BUILD_TYPE="Debug"
+        ;;
+    staging)
+        ENV_FILE=".env.staging"
+        BUILD_TYPE="Staging"
+        ;;
+    release|production)
+        ENV_FILE=".env.production"
+        BUILD_TYPE="Release"
+        ;;
+esac
+
+[ ! -f "$ENV_FILE" ] && ENV_FILE=".env"
+```
+
+### Step 2: Detect Project Type
+
+```bash
+detect_android_project() {
+    if [ -d "android" ] && [ -f "android/build.gradle" ]; then
+        [ -f "package.json" ] && grep -q "react-native" package.json && echo "react-native" && return
+        [ -f "capacitor.config.json" ] && echo "capacitor" && return
+        [ -f "pubspec.yaml" ] && echo "flutter" && return
+        echo "native"
+    else
+        echo "unknown"
+    fi
+}
+
+PROJECT_TYPE=$(detect_android_project)
+
+[ ! -d "android" ] && echo "❌ android/ directory not found" && exit 1
+```
+
+### Step 3: Install Dependencies
+
+```bash
+# Gradle wrapper
+[ -f "android/gradlew" ] && chmod +x android/gradlew
+
+# npm
+if [ -f "package.json" ] && [ ! -d "node_modules" ]; then
+    npm install
+fi
+```
+
+### Step 4: Setup Android Emulator
+
+```bash
+! command -v adb &> /dev/null && echo "❌ adb not found. Is Android SDK installed?" && exit 1
+
+! emulator -list-avds 2>/dev/null | grep -q "^${DEVICE}$" && echo "❌ Emulator '$DEVICE' not found" && emulator -list-avds && exit 1
+
+RUNNING_EMULATOR=$(adb devices | grep "emulator" | cut -f1)
+
+if [ -z "$RUNNING_EMULATOR" ]; then
+    emulator -avd "$DEVICE" -no-snapshot-load -no-boot-anim &
+    adb wait-for-device
+    sleep 5
+    while [ "$(adb shell getprop sys.boot_completed 2>/dev/null | tr -d '\r')" != "1" ]; do
+        sleep 2
+    done
+fi
+
+EMULATOR_SERIAL=$(adb devices | grep "emulator" | cut -f1 | head -1)
+```
+
+### Step 5: Setup Port Forwarding
+
+```bash
+# For dev server access from emulator
+if [ "$PROJECT_TYPE" = "react-native" ] || grep -q "\"dev\":" package.json 2>/dev/null; then
+    DEV_PORT=$(shuf -i 3000-9999 -n 1)
+    adb -s "$EMULATOR_SERIAL" reverse tcp:$DEV_PORT tcp:$DEV_PORT
+fi
+```
+
+### Step 6: Configure Poltergeist (Optional)
+
+```bash
+POLTERGEIST_AVAILABLE=false
+
+if command -v poltergeist &> /dev/null; then
+    POLTERGEIST_AVAILABLE=true
+
+    [ ! -f ".poltergeist.yml" ] && cat > .poltergeist.yml <<EOF
+platform: android
+watchPaths:
+  - android/app/src/**/*.kt
+  - android/app/src/**/*.java
+  - android/app/src/**/*.xml
+ignorePaths:
+  - android/app/build/**
+  - android/.gradle/**
+buildCommand: |
+  cd android && ./gradlew assemble${BUILD_TYPE} && cd ..
+installCommand: |
+  adb -s $EMULATOR_SERIAL install -r android/app/build/outputs/apk/${VARIANT}/app-${VARIANT}.apk
+EOF
+fi
+```
+
+### Step 7: Create tmux Session
+
+```bash
+PROJECT_NAME=$(basename "$(pwd)")
+TIMESTAMP=$(date +%s)
+SESSION="android-${PROJECT_NAME}-${TIMESTAMP}"
+
+tmux new-session -d -s "$SESSION" -n build
+```
+
+### Step 8: Build & Install
+
+```bash
+case $PROJECT_TYPE in
+    react-native)
+        tmux send-keys -t "$SESSION:build" "npx react-native run-android --variant=$VARIANT --deviceId=$EMULATOR_SERIAL" C-m
+        ;;
+    capacitor)
+        tmux send-keys -t "$SESSION:build" "npx cap sync android && npx cap run android --target=$EMULATOR_SERIAL" C-m
+        ;;
+    flutter)
+        tmux send-keys -t "$SESSION:build" "flutter run -d $EMULATOR_SERIAL --flavor $VARIANT" C-m
+        ;;
+    native)
+        tmux send-keys -t "$SESSION:build" "cd android && ./gradlew install${BUILD_TYPE} && cd .." C-m
+        ;;
+esac
+```
+
+### Step 9: Setup Additional Windows
+
+```bash
+# Dev server (if needed)
+if [ "$PROJECT_TYPE" = "react-native" ] || grep -q "\"dev\":" package.json 2>/dev/null; then
+    tmux new-window -t "$SESSION" -n dev-server
+    tmux send-keys -t "$SESSION:dev-server" "PORT=$DEV_PORT npm start | tee dev-server.log" C-m
+fi
+
+# Poltergeist (if available)
+if [ "$POLTERGEIST_AVAILABLE" = true ]; then
+    tmux new-window -t "$SESSION" -n poltergeist
+    tmux send-keys -t "$SESSION:poltergeist" "poltergeist watch --platform android | tee poltergeist.log" C-m
+fi
+
+# Logs
+tmux new-window -t "$SESSION" -n logs
+tmux send-keys -t "$SESSION:logs" "adb -s $EMULATOR_SERIAL logcat -v color" C-m
+
+# Git
+tmux new-window -t "$SESSION" -n git
+tmux send-keys -t "$SESSION:git" "git status" C-m
+```
+
+### Step 10: Save Metadata
+
+```bash
+cat > .tmux-android-session.json <<EOF
+{
+  "session": "$SESSION",
+  "project": "$PROJECT_NAME",
+  "type": "$PROJECT_TYPE",
+  "variant": "$VARIANT",
+  "environment": "$ENV_FILE",
+  "emulator": {
+    "name": "$DEVICE",
+    "serial": "$EMULATOR_SERIAL"
+  },
+  "poltergeist": $POLTERGEIST_AVAILABLE,
+  "created": "$(date -Iseconds)"
+}
+EOF
+```
+
+### Step 11: Display Summary
+
+```bash
+echo ""
+echo "✨ Android Dev Environment Started: $SESSION"
+echo ""
+echo "Variant: $VARIANT ($ENV_FILE)"
+echo "Emulator: $DEVICE ($EMULATOR_SERIAL)"
+[ "$POLTERGEIST_AVAILABLE" = true ] && echo "Poltergeist: Auto-rebuild enabled"
+echo ""
+echo "Attach: tmux attach -t $SESSION"
+echo "Status: /tmux-status"
+echo ""
+```
+
+## Notes
+
+- Auto-detects: React Native, Capacitor, Flutter, Native Android
+- Maps build variant to environment file
+- Poltergeist enables auto-rebuild on file changes
+- Port forwarding for emulator to access localhost dev server
+- Session persists across disconnects