@humanu/orchestra 0.5.2 → 0.5.3

package/resources/scripts/gw-bridge.sh

@@ -0,0 +1,1184 @@
+#!/bin/bash
+
+###############################################################################
+# gw-bridge.sh – API bridge between Rust TUI and bash APIs
+# ---------------------------------------------------------------------------
+# This script sources the existing git.sh and tmux.sh APIs and exposes them
+# via a JSON interface for the Rust TUI application to consume.
+###############################################################################
+
+set -euo pipefail
+
+# Source the API modules
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/api/git.sh"
+source "$SCRIPT_DIR/api/tmux.sh"
+
+# Define utilities we need
+err() { printf '❌ %s\n' "$*" >&2; }
+info() { printf '%s\n' "$*"; }
+have_cmd() { command -v "$1" >/dev/null 2>&1; }
+
+# Check if jq is available for JSON processing
+if ! have_cmd jq; then
+  err "jq is required for JSON processing but not installed"
+  exit 1
+fi
+
+# Helper function to output JSON safely
+json_output() {
+  if [[ $# -eq 0 ]]; then
+    echo "null"
+  else
+    printf '%s\n' "$@" | jq -R -s 'split("\n")[:-1]'
+  fi
+}
+
+# Extract a concise summary line from git output for error dialogs
+git_error_summary() {
+  local text="${1-}"
+  local trimmed=""
+  local candidate=""
+  local fallback=""
+  while IFS= read -r line; do
+    line="${line%$'\r'}" # drop trailing carriage returns
+    trimmed="${line#${line%%[![:space:]]*}}"
+    if [[ -z "${trimmed//[[:space:]]/}" ]]; then
+      continue
+    fi
+    local is_hint=0
+    if [[ $trimmed == hint:* || $trimmed == Hint:* ]]; then
+      is_hint=1
+    fi
+    if [[ $is_hint -eq 0 ]]; then
+      fallback="$trimmed"
+    elif [[ -z "$fallback" ]]; then
+      fallback="$trimmed"
+    fi
+    if [[ $is_hint -eq 0 ]]; then
+      case "$trimmed" in
+        fatal:*|Fatal:*|error:*|Error:*|CONFLICT*|Conflict*|\
+          *merge\ failed*|*Merge\ failed*|\
+          *could\ not\ apply*)
+          candidate="$trimmed"
+          ;;
+      esac
+    fi
+  done <<<"$text"
+  if [[ -n "$candidate" ]]; then
+    printf '%s' "$candidate"
+  else
+    printf '%s' "$fallback"
+  fi
+}
+
+# Helper function to output structured worktree data
+json_worktrees() {
+  git_list_worktrees | jq -R -s '
+    split("\n")[:-1] | 
+    map(split("\t")) | 
+    map({
+      path: .[0], 
+      branch: .[1], 
+      sha: .[2]
+    })'
+}
+
+# Helper function to load Anthropic API key from config or .env file
+load_anthropic_api_key() {
+  # First try to load from ~/.orchestra/config.json
+  local config_file="$HOME/.orchestra/config.json"
+  if [[ -f "$config_file" ]] && have_cmd jq; then
+    local api_key
+    api_key="$(jq -r '.anthropic_api_key // empty' "$config_file" 2>/dev/null)"
+    if [[ -n "$api_key" ]] && [[ "$api_key" != "null" ]]; then
+      export ANTHROPIC_API_KEY="$api_key"
+      return 0
+    fi
+  fi
+  
+  # Fallback to .env file in current directory
+  if [[ -f ".env" ]]; then
+    source .env
+  fi
+  
+  # Fallback to .env file in repo root
+  if [[ -z "${ANTHROPIC_API_KEY-}" ]]; then
+    local repo_root
+    repo_root="$(git_repo_root 2>/dev/null)"
+    if [[ -n "$repo_root" ]] && [[ -f "$repo_root/.env" ]]; then
+      source "$repo_root/.env"
+    fi
+  fi
+}
+
+# Helper function to output error
+json_error() {
+  local message="$1"
+  jq -n --arg msg "$message" '{"error": $msg}'
+}
+
+# Main command dispatcher
+case "${1:-}" in
+  "list-worktrees")
+    if git_require_repo_root >/dev/null 2>&1; then
+      json_worktrees
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "list-sessions")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Slug parameter required"
+      exit 1
+    fi
+    slug="$2"
+    # Optional third parameter for worktree path
+    worktree_path="${3:-}"
+    
+    if tmux_available; then
+      if [[ -n "$worktree_path" ]]; then
+        sessions_output="$(tmux_list_sessions_for_slug "$slug" "$worktree_path")"
+      else
+        sessions_output="$(tmux_list_sessions_for_slug "$slug")"
+      fi
+      if [[ -n "$sessions_output" ]]; then
+        printf '%s\n' "$sessions_output" | jq -R -s 'split("\n")[:-1]'
+      else
+        echo "null"
+      fi
+    else
+      echo "null"
+    fi
+    ;;
+    
+  "create-session")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Slug required"
+      exit 1
+    fi
+    slug="$2"
+    name="${3:-}"
+    path="${4:-$(pwd)}"
+    
+    if tmux_available; then
+      session_name="$(tmux_ensure_session "$slug" "$name" "$path")"
+      echo "\"$session_name\""
+    else
+      json_error "tmux not available"
+    fi
+    ;;
+
+  "create-session-exact")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    session_name="$2"
+    path="${3:-$(pwd)}"
+    if tmux_available; then
+      created="$(tmux_create_session "$session_name" "$path")" || { json_error "Failed to create exact session"; exit 1; }
+      echo "\"$created\""
+    else
+      json_error "tmux not available"
+    fi
+    ;;
+    
+  "kill-session")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    session_name="$2"
+    
+    if tmux_available; then
+      if tmux_kill_session "$session_name"; then
+        echo "true"
+      else
+        json_error "Failed to kill session"
+      fi
+    else
+      json_error "tmux not available"
+    fi
+    ;;
+    
+  "attach-session")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    session_name="$2"
+    
+    if tmux_available; then
+      tmux_attach_session "$session_name"
+      echo "true"
+    else
+      json_error "tmux not available"
+    fi
+    ;;
+  
+  "tmux-send-keys")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    session_name="$2"; shift 2 || true
+    if tmux_available; then
+      tmux_send_keys "$session_name" "$*" || { json_error "Failed to send keys"; exit 1; }
+      echo '{"ok":true}'
+    else
+      json_error "tmux not available"
+    fi
+    ;;
+    
+  "session-metadata")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    session_name="$2"
+    
+    if tmux_available; then
+      # Get tmux metadata for context detection
+      window_name=$(tmux display-message -t "$session_name" -p '#{window_name}' 2>/dev/null || echo "")
+      pane_title=$(tmux display-message -t "$session_name" -p '#{pane_title}' 2>/dev/null || echo "")
+      pane_cmd=$(tmux display-message -t "$session_name" -p '#{pane_current_command}' 2>/dev/null || echo "")
+      
+      # Return JSON with metadata
+      jq -n --arg window "$window_name" --arg title "$pane_title" --arg cmd "$pane_cmd" \
+        '{window_name: $window, pane_title: $title, current_command: $cmd}'
+    else
+      json_error "tmux not available"
+    fi
+    ;;
+    
+  "session-preview")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    session_name="$2"
+    
+    if tmux_available; then
+      preview="$(tmux_session_preview "$session_name")"
+      printf '%s\n' "$preview" | jq -R -s .
+    else
+      echo "\"tmux not available\""
+    fi
+    ;;
+    
+    "ai-generate-name-from-base64")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Base64 content required"
+      exit 1
+    fi
+    content_b64="$2"
+    load_anthropic_api_key
+    if [[ -z "${ANTHROPIC_API_KEY-}" ]]; then
+      echo "\"missing_api_key\""
+      exit 0
+    fi
+    # Build request via Python to ensure proper JSON encoding
+    request_body=$(python3 - "$content_b64" <<'PY'
+import sys, json, base64
+b64 = sys.argv[1]
+try:
+    content = base64.b64decode(b64.encode('utf-8')).decode('utf-8','ignore')
+except Exception:
+    content = ''
+prompt = f"""Analyze this terminal session and create a descriptive name based ONLY on the console output and commands executed.
+
+Terminal output:
+{content}
+
+IMPORTANT: Look carefully at the terminal output for:
+1. Commands that were executed (lines starting with $ or > or commands after prompts)
+2. Application output patterns (errors, build messages, server logs)
+3. Tool-specific output (git commands, npm/yarn, docker, ssh, etc.)
+4. AI coding assistant interactions (Claude Code, OpenCode, Cursor, etc.)
+5. Git-specific patterns and outputs
+
+CRITICAL GIT DETECTION: Check for ANY of these Git indicators in the last outputs:
+- Git commands: git status, git diff, git add, git commit, git push, git pull, git checkout, git branch, git merge, git rebase, git log, git stash, etc.
+- Git output patterns: \"On branch\", \"Your branch is\", \"Changes not staged\", \"Changes to be committed\", \"Untracked files\", \"modified:\", \"deleted:\", \"new file:\", \"renamed:\"
+- Git diff output: Lines starting with +, -, @@, diff --git
+- Git merge/rebase messages: \"CONFLICT\", \"Merge branch\", \"Rebase\", \"Cherry-pick\"
+- Git status indicators: \"nothing to commit\", \"working tree clean\", \"ahead of\", \"behind\"
+- Git error messages: \"fatal:\", \"error:\", \"warning:\" (when preceded by git commands)
+
+Use these prefixes based on detected application/context (PRIORITIZE git_ if Git patterns found):
+- git_ : ANY Git operations or Git output patterns detected (HIGHEST PRIORITY if found)
+- opencode_ : If you see Claude Code, OpenCode, Cursor, AI assistant interactions, or AI-powered coding
+- running_ : Dev servers (npm run dev, yarn dev, python manage.py runserver, rails server, etc.)
+- build_ : Build processes (npm run build, cargo build, make, webpack, etc.)
+- test_ : Testing (npm test, pytest, jest, cargo test, etc.)
+- docker_ : Docker commands, container operations
+- ssh_ : SSH connections, remote operations
+- db_ : Database operations (psql, mysql, mongo, migrations)
+- debug_ : Debugging sessions, error investigation
+- deploy_ : Deployment operations
+- Otherwise, no prefix for general development
+
+If Git patterns are detected, ALWAYS use git_ prefix, even if other activities are present.
+
+Describe what the user was actually doing based on the console output, not just the current state.
+
+The name should be max 100 chars total, use underscores only (no colons or special chars).
+
+Respond with ONLY the session name, nothing else."""
+
+req = {
+  "model": "claude-3-5-haiku-latest",
+  "max_tokens": 100,
+  "messages": [{"role":"user","content": prompt}]
+}
+print(json.dumps(req))
+PY
+)
+    response=$(curl -s -X POST https://api.anthropic.com/v1/messages \
+      --max-time 20 \
+      -H "Content-Type: application/json" \
+      -H "x-api-key: $ANTHROPIC_API_KEY" \
+      -H "anthropic-version: 2023-06-01" \
+      -d "$request_body" 2>/dev/null)
+    # Extract text
+    new_name=$(echo "$response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('content',[{}])[0].get('text',''))" 2>/dev/null)
+    # Clean and truncate
+    new_name=$(echo "$new_name" | tr ' ' '_' | sed 's/[^a-zA-Z0-9_-]//g' | cut -c1-100)
+    if [[ -z "$new_name" ]]; then
+      echo "\"ai_generation_failed\""
+    else
+      printf '"%s"\n' "$new_name"
+    fi
+    ;;
+    
+  "rename-session")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Session name required"
+      exit 1
+    fi
+    original_session_name="$2"
+    
+    # Load API key from config file or fallback to .env
+    load_anthropic_api_key
+    
+    if [[ -z "${ANTHROPIC_API_KEY-}" ]]; then
+      echo "\"missing_api_key\""
+      exit 0
+    fi
+    
+    # Check if tmux is available and session exists
+    if ! tmux_available; then
+      echo "\"tmux_not_available\""
+      exit 0
+    fi
+    
+    if ! tmux_session_exists "$original_session_name"; then
+      echo "\"session_not_found\""
+      exit 0
+    fi
+    
+    # Generate AI name using the CURRENT session (no renaming to temp name)
+    ai_name="$(tmux_generate_ai_session_name "$original_session_name" 2>/dev/null)"
+    
+    if [[ -n "$ai_name" ]] && [[ "$ai_name" != *"error"* ]] && [[ "$ai_name" != *"Failed"* ]]; then
+      # Clean the AI name for session naming
+      ai_name="$(echo "$ai_name" | tr ' ' '_' | sed 's/[^a-zA-Z0-9_-]//g' | cut -c1-100)"
+      
+      # Remove any prefix from AI name to avoid duplication
+      ai_name="$(echo "$ai_name" | sed -E 's/^(opencode|running|ssh|docker|k8s|git|db)_//')"
+      
+      # Remove any leading underscores
+      ai_name="$(echo "$ai_name" | sed 's/^_*//')"
+      
+      # Perform the rename preserving canonical prefix and delimiter
+      if tmux_rename_session "$original_session_name" "$ai_name" >/dev/null; then
+        echo "\"success\""
+      else
+        echo "\"rename_failed\""
+      fi
+    else
+      # AI generation failed, keep original name
+      echo "\"ai_generation_failed\""
+    fi
+    ;;
+    
+  "manual-rename-session")
+    if [[ -z "${2:-}" ]] || [[ -z "${3:-}" ]]; then
+      json_error "Old and new session names required"
+      exit 1
+    fi
+    old_name="$2"
+    new_display_name="$3"
+    
+    if ! tmux_available; then
+      echo "\"tmux_not_available\""
+      exit 0
+    fi
+    
+    # Check if session exists
+    if ! tmux has-session -t "$old_name" 2>/dev/null; then
+      echo "\"session_not_found\""
+      exit 0
+    fi
+    
+    # Validate new display name (alphanumeric and underscore only)
+    if [[ ! "$new_display_name" =~ ^[a-zA-Z0-9_]+$ ]]; then
+      echo "\"invalid_name\""
+      exit 0
+    fi
+    
+    # Perform rename via tmux API to preserve delimiter and canonical prefix
+    if tmux_rename_session "$old_name" "$new_display_name" >/dev/null; then
+      echo "\"success\""
+    else
+      echo "\"rename_failed\""
+    fi
+    ;;
+    
+  "check-branch")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+
+    if git_require_repo_root >/dev/null 2>&1; then
+      local_exists="false"
+      if git_branch_exists "$branch_name"; then
+        local_exists="true"
+      fi
+
+      remote_exists="false"
+      remote_error=""
+      remote_name="origin"
+      root="$(git_repo_root)"
+
+      if (cd "$root" && git remote get-url "$remote_name" >/dev/null 2>&1); then
+        remote_output="$(cd "$root" && git ls-remote --heads "$remote_name" "$branch_name" 2>&1)"
+        remote_status=$?
+        if [[ $remote_status -eq 0 ]]; then
+          if [[ -n "$remote_output" ]]; then
+            remote_exists="true"
+          fi
+        else
+          remote_error="$remote_output"
+        fi
+      else
+        remote_error="Remote '$remote_name' not configured"
+      fi
+
+      if [[ -n "$remote_error" ]]; then
+        remote_error="$(printf '%s' "$remote_error" | tr '\n' ' ')"
+      fi
+
+      jq -n \
+        --argjson local "$local_exists" \
+        --argjson remote "$remote_exists" \
+        --arg remote_error "$remote_error" \
+        '{local_exists:$local, remote_exists:$remote} + (if ($remote_error | length) > 0 then {remote_error:$remote_error} else {} end)'
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+
+  "create-worktree")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+    
+    if git_require_repo_root >/dev/null 2>&1; then
+      worktree_path="$(git_create_branch_and_worktree "$branch_name")"
+      echo "\"$worktree_path\""
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+
+  "create-worktree-from-existing")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+
+    if git_require_repo_root >/dev/null 2>&1; then
+      if ! git_branch_exists "$branch_name"; then
+        json_error "Branch does not exist: $branch_name"
+        exit 1
+      fi
+
+      if git_worktree_exists_for_branch "$branch_name"; then
+        json_error "Worktree already exists for branch: $branch_name"
+        exit 1
+      fi
+
+      if worktree_path="$(git_create_worktree_for_existing_branch "$branch_name")"; then
+        echo "\"$worktree_path\""
+      else
+        json_error "Failed to create worktree for branch: $branch_name"
+      fi
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+
+  "create-worktree-from-remote")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+    remote_name="${3:-origin}"
+
+    if git_require_repo_root >/dev/null 2>&1; then
+      if git_worktree_exists_for_branch "$branch_name"; then
+        json_error "Worktree already exists for branch: $branch_name"
+        exit 1
+      fi
+
+      if worktree_path="$(git_create_worktree_from_remote_branch "$branch_name" "$remote_name")"; then
+        echo "\"$worktree_path\""
+      else
+        json_error "Failed to create worktree from remote branch: $remote_name/$branch_name"
+      fi
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+
+  "delete-worktree")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+    
+    if git_require_repo_root >/dev/null 2>&1; then
+      worktree_path="$(git_branch_to_worktree_path "$branch_name")"
+      
+      if [[ -n "$worktree_path" ]]; then
+        git_remove_worktree "$worktree_path"
+      fi
+      
+      if git_branch_exists "$branch_name"; then
+        git_delete_branch "$branch_name"
+      fi
+      
+      echo "true"
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "delete-worktree-only")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+    
+    if git_require_repo_root >/dev/null 2>&1; then
+      worktree_path="$(git_branch_to_worktree_path "$branch_name")"
+      
+      if [[ -n "$worktree_path" ]]; then
+        git_remove_worktree "$worktree_path"
+        echo "true"
+      else
+        json_error "No worktree found for branch: $branch_name"
+      fi
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "delete-branch-only")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Branch name required"
+      exit 1
+    fi
+    branch_name="$2"
+    
+    if git_require_repo_root >/dev/null 2>&1; then
+      if git_branch_exists "$branch_name"; then
+        git_delete_branch "$branch_name"
+        echo "true"
+      else
+        json_error "Branch does not exist: $branch_name"
+      fi
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "switch-worktree")
+    if [[ -z "${2:-}" ]]; then
+      json_error "Path required"
+      exit 1
+    fi
+    path="$2"
+    echo "\"cd \\\"$path\\\"\""
+    ;;
+    
+  "repo-info")
+    if git_require_repo_root >/dev/null 2>&1; then
+      root="$(git_repo_root)"
+      current_path="$(git_current_path)"
+      current_branch="$(git_current_branch)"
+      current_commit="$(git_current_commit_short)"
+      
+      jq -n \
+        --arg root "$root" \
+        --arg current_path "$current_path" \
+        --arg current_branch "$current_branch" \
+        --arg current_commit "$current_commit" \
+        '{
+          root: $root,
+          current_path: $current_path,
+          current_branch: $current_branch,
+          current_commit: $current_commit
+        }'
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "git-status")
+    if git_require_repo_root >/dev/null 2>&1; then
+      status_output="$(git status --porcelain 2>/dev/null || echo "")"
+      echo "\"$status_output\""
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "enhanced-git-status")
+    # Optional directory parameter - if provided, cd to that directory first
+    target_dir="${2:-}"
+    if [[ -n "$target_dir" ]]; then
+      if [[ ! -d "$target_dir" ]]; then
+        json_error "Directory does not exist: $target_dir"
+        exit 1
+      fi
+      cd "$target_dir" || {
+        json_error "Cannot change to directory: $target_dir"
+        exit 1
+      }
+    fi
+    
+    if git_require_repo_root >/dev/null 2>&1; then
+      # Get porcelain status
+      status_lines="$(git status --porcelain=v1 2>/dev/null)"
+      
+      # Get branch info
+      branch="$(git_current_branch)"
+      
+      # Get ahead/behind info (handle cases where upstream doesn't exist)
+      ahead_behind="$(git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null || echo "0	0")"
+      ahead="$(echo "$ahead_behind" | cut -f1)"
+      behind="$(echo "$ahead_behind" | cut -f2)"
+      
+      # Process each file and get diff stats
+      files_json="$(echo "$status_lines" | while IFS= read -r line; do
+        if [[ -n "$line" ]]; then
+          index_status="${line:0:1}"
+          workdir_status="${line:1:1}"
+          filepath="${line:3}"
+          
+          # Get diff stats for the file
+          added=0
+          deleted=0
+          
+          # Check for staged changes first
+          if [[ "$index_status" != " " && "$index_status" != "?" ]]; then
+            # Staged changes - use --cached
+            stats="$(git diff --cached --numstat "$filepath" 2>/dev/null | head -1)"
+            if [[ -n "$stats" && "$stats" != "-	-"* ]]; then
+              added="$(echo "$stats" | cut -f1)"
+              deleted="$(echo "$stats" | cut -f2)"
+              # Handle binary files (shows -)
+              [[ "$added" == "-" ]] && added=0
+              [[ "$deleted" == "-" ]] && deleted=0
+            fi
+          fi
+          
+          # Check for working directory changes if no staged stats or if workdir is also modified
+          if [[ "$workdir_status" != " " && "$workdir_status" != "?" ]] && [[ $added -eq 0 && $deleted -eq 0 ]]; then
+            # Working directory changes
+            stats="$(git diff --numstat "$filepath" 2>/dev/null | head -1)"
+            if [[ -n "$stats" && "$stats" != "-	-"* ]]; then
+              added="$(echo "$stats" | cut -f1)"
+              deleted="$(echo "$stats" | cut -f2)"
+              # Handle binary files (shows -)
+              [[ "$added" == "-" ]] && added=0
+              [[ "$deleted" == "-" ]] && deleted=0
+            fi
+          fi
+          
+          # For untracked files, try to count lines
+          if [[ "$index_status" == "?" && "$workdir_status" == "?" ]]; then
+            if [[ -f "$filepath" ]]; then
+              # Count lines in new file
+              line_count="$(wc -l < "$filepath" 2>/dev/null || echo "0")"
+              added="$line_count"
+              deleted=0
+            fi
+          fi
+          
+          # Output JSON for this file
+          jq -n --arg path "$filepath" \
+                --arg idx "$index_status" \
+                --arg wd "$workdir_status" \
+                --argjson add "$added" \
+                --argjson del "$deleted" \
+                '{path: $path, index_status: $idx, workdir_status: $wd, lines_added: $add, lines_deleted: $del}'
+        fi
+      done | jq -s .)"
+      
+      # Handle empty files array
+      if [[ -z "$files_json" || "$files_json" == "null" ]]; then
+        files_json="[]"
+      fi
+      
+      # Combine into final JSON
+      jq -n --arg branch "$branch" \
+            --argjson ahead "$ahead" \
+            --argjson behind "$behind" \
+            --argjson files "$files_json" \
+            '{branch: $branch, ahead: $ahead, behind: $behind, files: $files}'
+    else
+      json_error "Not a git repository"
+    fi
+    ;;
+    
+  "primary-branch")
+    if pr=$(git_primary_branch); then
+      jq -n --arg primary "$pr" '{ok:true, primary:$primary}'
+    else
+      jq -n '{ok:false, error_type:"no_primary_detected", message:"Could not detect primary branch"}'
+    fi
+    ;;
+
+  "merge-from-primary")
+    # Parse args: --worktree <path> --branch <name>
+    shift || true
+    wt=""; br=""
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --worktree) wt="$2"; shift 2;;
+        --branch) br="$2"; shift 2;;
+        *) shift;;
+      esac
+    done
+    if [[ -z "$wt" || -z "$br" ]]; then
+      json_error "--worktree and --branch required"; exit 1
+    fi
+    if ! git_require_repo_root >/dev/null 2>&1; then
+      json_error "Not a git repository"; exit 1
+    fi
+    pr="$(git_primary_branch || true)"
+    if [[ -z "$pr" ]]; then
+      jq -n --arg op "merge-from-primary" '{ok:false, operation:$op, error_type:"no_primary_detected", message:"Could not detect primary branch"}'
+      exit 0
+    fi
+    LOGS=""
+    append() { LOGS+="$1"$'\n'; }
+    # Fetch in target worktree
+    append "$ git -C $wt fetch origin --prune"
+    append "$(git_fetch_prune "$wt")"
+    # If primary worktree exists, update it fast-forward-only
+    pr_path="$(git_branch_to_worktree_path "$pr" || true)"
+    if [[ -n "$pr_path" ]]; then
+      if ! git_is_worktree_clean "$pr_path"; then
+        logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+        jq -n --arg op "merge-from-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" \
+          --arg message "Primary worktree is dirty" --arg error_type "dirty_primary" --argjson logs "$logs_json" \
+          '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, target_path:$target_path, logs:$logs}'
+        exit 0
+      fi
+    append "$ git -C $pr_path pull --ff-only"
+    set +e
+    pull_out="$(git_pull_ff_only "$pr_path")"
+    sts=$?
+    set -e
+      append "$pull_out"
+      if [[ $sts -ne 0 ]]; then
+        logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+        jq -n --arg op "merge-from-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" \
+          --arg message "Primary cannot fast-forward" --arg error_type "ff_only_failed" --argjson logs "$logs_json" \
+          '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, target_path:$target_path, logs:$logs}'
+        exit 0
+      fi
+    fi
+    # Choose ref to merge
+    if git -C "$wt" rev-parse --verify "origin/$pr" >/dev/null 2>&1; then
+      ref="origin/$pr"
+    else
+      ref="$pr"
+    fi
+    append "$ git -C $wt merge $ref"
+    set +e
+    out="$(git_merge_into "$wt" "$ref")"
+    rc=$?
+    set -e
+    append "$out"
+    summary="$(git_error_summary "$out")"
+    if [[ -z "$summary" ]]; then
+      summary="Merge conflict or error"
+    fi
+    logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+    if [[ $rc -eq 0 ]]; then
+      result="merged"
+      if echo "$out" | grep -qi 'already up[- ]to[- ]date'; then result="up_to_date"; fi
+      jq -n --arg op "merge-from-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" --arg result "$result" --argjson logs "$logs_json" \
+        '{ok:true, operation:$op, primary:$primary, target_branch:$target_branch, target_path:$target_path, result:$result, logs:$logs}'
+    else
+      jq -n --arg op "merge-from-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" \
+        --arg message "$summary" --arg error_type "merge_conflict" --argjson logs "$logs_json" \
+        '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, target_path:$target_path, logs:$logs}'
+    fi
+    ;;
+
+  "rebase-from-primary")
+    shift || true
+    wt=""; br=""
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --worktree) wt="$2"; shift 2;;
+        --branch) br="$2"; shift 2;;
+        *) shift;;
+      esac
+    done
+    if [[ -z "$wt" || -z "$br" ]]; then
+      json_error "--worktree and --branch required"; exit 1
+    fi
+    if ! git_require_repo_root >/dev/null 2>&1; then
+      json_error "Not a git repository"; exit 1
+    fi
+    pr="$(git_primary_branch || true)"
+    if [[ -z "$pr" ]]; then
+      jq -n --arg op "rebase-from-primary" '{ok:false, operation:$op, error_type:"no_primary_detected", message:"Could not detect primary branch"}'
+      exit 0
+    fi
+    LOGS=""; append() { LOGS+="$1"$'\n'; }
+    append "$ git -C $wt fetch origin --prune"
+    append "$(git_fetch_prune "$wt")"
+    if git -C "$wt" rev-parse --verify "origin/$pr" >/dev/null 2>&1; then
+      upstream="origin/$pr"
+    else
+      upstream="$pr"
+    fi
+    append "$ git -C $wt rebase $upstream"
+    set +e
+    out="$(git_rebase_onto "$wt" "$upstream")"
+    rc=$?
+    set -e
+    append "$out"
+    summary="$(git_error_summary "$out")"
+    if [[ -z "$summary" ]]; then
+      summary="Rebase conflict or error"
+    fi
+    logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+    if [[ $rc -eq 0 ]]; then
+      result="rebased"
+      if echo "$out" | grep -qi 'up[- ]to[- ]date'; then result="up_to_date"; fi
+      jq -n --arg op "rebase-from-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" --arg result "$result" --argjson logs "$logs_json" \
+        '{ok:true, operation:$op, primary:$primary, target_branch:$target_branch, target_path:$target_path, result:$result, logs:$logs}'
+    else
+      jq -n --arg op "rebase-from-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" \
+        --arg message "$summary" --arg error_type "rebase_conflict" --argjson logs "$logs_json" \
+        '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, target_path:$target_path, logs:$logs}'
+    fi
+    ;;
+
+  "merge-into-primary")
+    shift || true
+    wt=""; br=""; msg=""
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --worktree) wt="$2"; shift 2;;
+        --branch) br="$2"; shift 2;;
+        --message) msg="$2"; shift 2;;
+        *) shift;;
+      esac
+    done
+    if [[ -z "$wt" || -z "$br" ]]; then
+      json_error "--worktree and --branch required"; exit 1
+    fi
+    if ! git_require_repo_root >/dev/null 2>&1; then
+      json_error "Not a git repository"; exit 1
+    fi
+    pr="$(git_primary_branch || true)"
+    if [[ -z "$pr" ]]; then
+      jq -n --arg op "merge-into-primary" '{ok:false, operation:$op, error_type:"no_primary_detected", message:"Could not detect primary branch"}'
+      exit 0
+    fi
+    LOGS=""; append() { LOGS+="$1"$'\n'; }
+    pr_path="$(git_ensure_primary_worktree || true)"
+    if [[ -z "$pr_path" ]]; then
+      jq -n --arg op "merge-into-primary" '{ok:false, operation:$op, error_type:"ensure_primary_failed", message:"Failed to ensure primary worktree"}'
+      exit 0
+    fi
+    if ! git_is_worktree_clean "$pr_path"; then
+      jq -n --arg op "merge-into-primary" --arg primary "$pr" --arg message "Primary worktree is dirty" '{ok:false, operation:$op, error_type:"dirty_primary", message:$message, primary:$primary}'
+      exit 0
+    fi
+    append "$ git -C $pr_path fetch origin --prune"
+    append "$(git_fetch_prune "$pr_path")"
+    append "$ git -C $pr_path pull --ff-only"
+    set +e
+    pull_out="$(git_pull_ff_only "$pr_path")"
+    pull_rc=$?
+    set -e
+    append "$pull_out"
+    if [[ $pull_rc -ne 0 ]]; then
+      logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+      jq -n --arg op "merge-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg target_path "$wt" \
+        --arg message "Primary cannot fast-forward" --arg error_type "ff_only_failed" --argjson logs "$logs_json" \
+        '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, target_path:$target_path, logs:$logs}'
+      exit 0
+    fi
+    if [[ -n "$msg" ]]; then
+      append "$ git -C $pr_path merge --no-ff -m '$msg' $br"
+      set +e
+      out="$(git -C "$pr_path" merge --no-ff -m "$msg" "$br" 2>&1)"
+      rc=$?
+      set -e
+    else
+      append "$ git -C $pr_path merge --no-ff $br"
+      set +e
+      out="$(git -C "$pr_path" merge --no-ff "$br" 2>&1)"
+      rc=$?
+      set -e
+    fi
+    append "$out"
+    summary="$(git_error_summary "$out")"
+    if [[ -z "$summary" ]]; then
+      summary="Merge conflict or error"
+    fi
+    logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+    if [[ $rc -eq 0 ]]; then
+      # Detect no-op merge (already up to date)
+      result="merged"
+      if echo "$out" | grep -qi 'already up[ -]to[ -]date'; then
+        result="up_to_date"
+      fi
+      jq -n --arg op "merge-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" --arg result "$result" --argjson logs "$logs_json" \
+        '{ok:true, operation:$op, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, result:$result, logs:$logs}'
+    else
+      jq -n --arg op "merge-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" \
+        --arg message "$summary" --arg error_type "merge_conflict" --argjson logs "$logs_json" \
+        '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, logs:$logs}'
+    fi
+    ;;
+
+  "squash-into-primary")
+    shift || true
+    wt=""; br=""; msg=""
+    while [[ $# -gt 0 ]]; do
+      case "$1" in
+        --worktree) wt="$2"; shift 2;;
+        --branch) br="$2"; shift 2;;
+        --message) msg="$2"; shift 2;;
+        *) shift;;
+      esac
+    done
+    if [[ -z "$wt" || -z "$br" ]]; then
+      json_error "--worktree and --branch required"; exit 1
+    fi
+    if ! git_require_repo_root >/dev/null 2>&1; then
+      json_error "Not a git repository"; exit 1
+    fi
+    pr="$(git_primary_branch || true)"
+    if [[ -z "$pr" ]]; then
+      jq -n --arg op "squash-into-primary" '{ok:false, operation:$op, error_type:"no_primary_detected", message:"Could not detect primary branch"}'
+      exit 0
+    fi
+    LOGS=""; append() { LOGS+="$1"$'\n'; }
+    pr_path="$(git_ensure_primary_worktree || true)"
+    if [[ -z "$pr_path" ]]; then
+      jq -n --arg op "squash-into-primary" '{ok:false, operation:$op, error_type:"ensure_primary_failed", message:"Failed to ensure primary worktree"}'
+      exit 0
+    fi
+    if ! git_is_worktree_clean "$pr_path"; then
+      jq -n --arg op "squash-into-primary" --arg primary "$pr" --arg message "Primary worktree is dirty" '{ok:false, operation:$op, error_type:"dirty_primary", message:$message, primary:$primary}'
+      exit 0
+    fi
+    append "$ git -C $pr_path fetch origin --prune"
+    append "$(git_fetch_prune "$pr_path")"
+    append "$ git -C $pr_path pull --ff-only"
+    set +e
+    pull_out="$(git_pull_ff_only "$pr_path")"
+    pull_rc=$?
+    set -e
+    append "$pull_out"
+    if [[ $pull_rc -ne 0 ]]; then
+      logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+      jq -n --arg op "squash-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" \
+        --arg message "Primary cannot fast-forward" --arg error_type "ff_only_failed" --argjson logs "$logs_json" \
+        '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, logs:$logs}'
+      exit 0
+    fi
+    append "$ git -C $pr_path merge --squash $br"
+    set +e
+    out="$(git -C "$pr_path" merge --squash "$br" 2>&1)"
+    rc=$?
+    set -e
+    append "$out"
+    if [[ $rc -ne 0 ]]; then
+      summary="$(git_error_summary "$out")"
+      if [[ -z "$summary" ]]; then
+        summary="Squash merge conflict or error"
+      fi
+      logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+      jq -n --arg op "squash-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" \
+        --arg message "$summary" --arg error_type "merge_conflict" --argjson logs "$logs_json" \
+        '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, logs:$logs}'
+      exit 0
+    fi
+    # If there are staged changes, commit them
+    if git -C "$pr_path" diff --cached --quiet; then
+      # Nothing to commit
+      logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+      jq -n --arg op "squash-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" --arg result "up_to_date" --argjson logs "$logs_json" \
+        '{ok:true, operation:$op, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, result:$result, logs:$logs}'
+    else
+      if [[ -n "$msg" ]]; then
+        append "$ git -C $pr_path commit -m '$msg'"
+        set +e
+        com_out="$(git -C "$pr_path" commit -m "$msg" 2>&1)"
+        crc=$?
+        set -e
+      else
+        append "$ git -C $pr_path commit -m 'Squash merge ${br} into ${pr}'"
+        set +e
+        com_out="$(git -C "$pr_path" commit -m "Squash merge ${br} into ${pr}" 2>&1)"
+        crc=$?
+        set -e
+      fi
+      append "$com_out"
+      logs_json="$(printf '%s\n' "$LOGS" | jq -R -s 'split("\n")[:-1]')"
+      if [[ $crc -eq 0 ]]; then
+        jq -n --arg op "squash-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" --arg result "squashed" --argjson logs "$logs_json" \
+          '{ok:true, operation:$op, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, result:$result, logs:$logs}'
+      else
+        jq -n --arg op "squash-into-primary" --arg primary "$pr" --arg target_branch "$br" --arg primary_path "$pr_path" \
+          --arg message "Commit failed after squash" --arg error_type "commit_failed" --argjson logs "$logs_json" \
+          '{ok:false, operation:$op, error_type:$error_type, message:$message, primary:$primary, target_branch:$target_branch, primary_path:$primary_path, logs:$logs}'
+      fi
+    fi
+    ;;
+
+  "tmux-available")
+    if tmux_available; then
+      echo "true"
+    else
+      echo "false"
+    fi
+    ;;
+    
+  "copy-env-files")
+    if [[ -z "${2:-}" ]] || [[ -z "${3:-}" ]]; then
+      json_error "Source and target paths required"
+      exit 1
+    fi
+    source_path="$2"
+    target_path="$3"
+    
+    # Copy .env files using the same logic as commands.sh
+    copy_success=0
+    
+    # Copy root .env file
+    if [[ -f "$source_path/.env" ]]; then
+      cp "$source_path/.env" "$target_path/.env" 2>/dev/null && copy_success=1
+    fi
+    
+    # Copy nodejs .env files
+    if [[ -d "$source_path/nodejs" ]]; then
+      mkdir -p "$target_path/nodejs"
+      for env_file in "$source_path/nodejs"/.env*; do
+        [[ -f "$env_file" ]] || continue
+        cp "$env_file" "$target_path/nodejs/$(basename "$env_file")" 2>/dev/null && copy_success=1
+      done
+    fi
+    
+    # Copy nextjs .env files
+    if [[ -d "$source_path/nextjs" ]]; then
+      mkdir -p "$target_path/nextjs"
+      for env_file in "$source_path/nextjs"/.env*; do
+        [[ -f "$env_file" ]] || continue
+        cp "$env_file" "$target_path/nextjs/$(basename "$env_file")" 2>/dev/null && copy_success=1
+      done
+    fi
+    
+    # Copy ingest_py .env files
+    if [[ -d "$source_path/ingest_py" ]]; then
+      mkdir -p "$target_path/ingest_py"
+      for env_file in "$source_path/ingest_py"/.env*; do
+        [[ -f "$env_file" ]] || continue
+        cp "$env_file" "$target_path/ingest_py/$(basename "$env_file")" 2>/dev/null && copy_success=1
+      done
+    fi
+    
+    if [[ $copy_success -eq 1 ]]; then
+      echo "true"
+    else
+      echo "false"
+    fi
+    ;;
+    
+  "help"|"-h"|"--help")
+    cat << 'EOF'
+Usage: gw-bridge.sh <command> [args]
+
+API bridge for gw-tui Rust application.
+
+Commands:
+  list-worktrees                    List all worktrees as JSON
+  list-sessions <slug>              List tmux sessions for worktree slug
+  create-session <slug> [name] [path]  Create new tmux session
+  kill-session <session>            Kill tmux session
+  attach-session <session>          Attach to tmux session
+  session-metadata <session>        Get session metadata (window, pane, command)
+   session-preview <session>         Get session preview text
+   tmux-send-keys <session> <cmd>    Send command to session and press Enter
+
+
+  check-branch <branch>             Check local/remote branch existence
+  create-worktree <branch>          Create new worktree and branch
+  create-worktree-from-existing <branch>
+                                    Create worktree from existing local branch
+  create-worktree-from-remote <branch> [remote]
+                                    Create worktree from remote branch
+  delete-worktree <branch>          Delete worktree and branch
+  delete-worktree-only <branch>     Delete worktree only (keep branch)
+  delete-branch-only <branch>       Delete branch only (keep worktree)
+  switch-worktree <path>            Generate cd command for path
+  copy-env-files <source> <target>  Copy .env files between directories
+  repo-info                         Get repository information
+  git-status                        Get git status --porcelain
+  enhanced-git-status [dir]         Get enhanced git status with file stats and line counts
+  primary-branch                    Detect primary branch name
+  merge-from-primary --worktree <path> --branch <name>
+                                    Merge primary into selected branch
+  rebase-from-primary --worktree <path> --branch <name>
+                                    Rebase selected branch onto primary
+  merge-into-primary --worktree <path> --branch <name> [--message <msg>]
+                                    Merge selected branch into primary (merge commit)
+  squash-into-primary --worktree <path> --branch <name> [--message <msg>]
+                                    Squash selected branch into primary (single commit)
+  tmux-available                    Check if tmux is available
+  help                              Show this help
+
+All commands return JSON output or JSON errors.
+EOF
+    ;;
+    
+  *)
+    json_error "Unknown command: ${1:-}. Use 'help' for usage."
+    exit 1
+    ;;
+esac