Project Session Manager

#!/usr/bin/env bash
# PSM Configuration Management

PSM_ROOT="${HOME}/.psm"
PSM_WORKTREES="${PSM_ROOT}/worktrees"
PSM_PROJECTS="${PSM_ROOT}/projects.json"
PSM_SESSIONS="${PSM_ROOT}/sessions.json"
PSM_LOGS="${PSM_ROOT}/logs"

# Initialize PSM directories and config files
psm_init() {
    mkdir -p "$PSM_WORKTREES" "$PSM_LOGS"

    # Create default projects.json if not exists
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        cat > "$PSM_PROJECTS" << 'EOF'
{
  "aliases": {
    "omc": {
      "repo": "Yeachan-Heo/oh-my-claudecode",
      "local": "~/Workspace/oh-my-claudecode",
      "default_base": "main"
    }
  },
  "defaults": {
    "worktree_root": "~/.psm/worktrees",
    "cleanup_after_days": 14,
    "auto_cleanup_merged": true
  }
}
EOF
        echo "Created default projects.json"
    fi

    # Create sessions.json if not exists
    if [[ ! -f "$PSM_SESSIONS" ]]; then
        echo '{"version":1,"sessions":{},"stats":{"total_created":0,"total_cleaned":0}}' > "$PSM_SESSIONS"
        echo "Created sessions.json"
    fi
}

# Get project config by alias
# Usage: psm_get_project "omc"
# Returns: repo|local|default_base
psm_get_project() {
    local alias="$1"
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        return 1
    fi

    local repo=$(jq -r --arg a "$alias" '.aliases[$a].repo // empty' "$PSM_PROJECTS")
    local local_path=$(jq -r --arg a "$alias" '.aliases[$a].local // empty' "$PSM_PROJECTS")
    local default_base=$(jq -r --arg a "$alias" '.aliases[$a].default_base // "main"' "$PSM_PROJECTS")

    local clone_url=$(jq -r --arg a "$alias" '.aliases[$a].clone_url // empty' "$PSM_PROJECTS")
    if [[ -z "$repo" && -z "$clone_url" ]]; then
        return 1
    fi

    # Expand ~ to $HOME
    local_path="${local_path/#\~/$HOME}"

    echo "${repo}|${local_path}|${default_base}"
}

# Get provider for a project alias
# Usage: psm_get_project_provider "mywork"
# Returns: "github" | "jira" | empty (defaults to github)
psm_get_project_provider() {
    local alias="$1"
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        echo "github"
        return
    fi
    local provider
    provider=$(jq -r --arg a "$alias" '.aliases[$a].provider // "github"' "$PSM_PROJECTS")
    echo "$provider"
}

# Get Jira project key for alias
# Usage: psm_get_project_jira_project "mywork"
# Returns: "MYPROJ" or empty
psm_get_project_jira_project() {
    local alias="$1"
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        return
    fi
    jq -r --arg a "$alias" '.aliases[$a].jira_project // empty' "$PSM_PROJECTS"
}

# Get explicit clone_url for alias (for non-GitHub repos)
# Usage: psm_get_project_clone_url "mywork"
# Returns: URL or empty
psm_get_project_clone_url() {
    local alias="$1"
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        return
    fi
    jq -r --arg a "$alias" '.aliases[$a].clone_url // empty' "$PSM_PROJECTS"
}

# Get repo field for alias
# Usage: psm_get_project_repo "mywork"
# Returns: "owner/repo" or empty
psm_get_project_repo() {
    local alias="$1"
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        return
    fi
    jq -r --arg a "$alias" '.aliases[$a].repo // empty' "$PSM_PROJECTS"
}

# Add or update project alias
psm_set_project() {
    local alias="$1"
    local repo="$2"
    local local_path="$3"
    local default_base="${4:-main}"

    local tmp=$(mktemp)
    jq --arg a "$alias" --arg r "$repo" --arg l "$local_path" --arg b "$default_base" \
        '.aliases[$a] = {"repo": $r, "local": $l, "default_base": $b}' \
        "$PSM_PROJECTS" > "$tmp" && mv "$tmp" "$PSM_PROJECTS"
}

# Get default worktree root
psm_get_worktree_root() {
    local root=$(jq -r '.defaults.worktree_root // "~/.psm/worktrees"' "$PSM_PROJECTS")
    echo "${root/#\~/$HOME}"
}

# Get cleanup days setting
psm_get_cleanup_days() {
    jq -r '.defaults.cleanup_after_days // 14' "$PSM_PROJECTS"
}

#!/usr/bin/env bash
# PSM Reference Parser

# Parse a reference string into components
# Supports:
#   omc#123           -> alias=omc, number=123
#   owner/repo#123    -> repo=owner/repo, number=123
#   https://...       -> parsed from URL
#   #123              -> number=123 (use current repo)
#
# Usage: psm_parse_ref "omc#123"
# Returns: type|alias|repo|number|local_path|base|provider|provider_ref
psm_parse_ref() {
    local ref="$1"
    local type=""
    local alias=""
    local repo=""
    local number=""
    local local_path=""
    local base="main"

    # GitHub PR URL
    if [[ "$ref" =~ ^https://github\.com/([^/]+)/([^/]+)/pull/([0-9]+) ]]; then
        repo="${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
        number="${BASH_REMATCH[3]}"
        type="pr"
        # Try to find alias for this repo
        alias=$(psm_find_alias_for_repo "$repo")
        if [[ -n "$alias" ]]; then
            IFS='|' read -r _ local_path base <<< "$(psm_get_project "$alias")"
        fi
        echo "pr|${alias:-}|$repo|$number|${local_path:-}|$base|github|${repo}#${number}"
        return 0
    fi

    # GitHub Issue URL
    if [[ "$ref" =~ ^https://github\.com/([^/]+)/([^/]+)/issues/([0-9]+) ]]; then
        repo="${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
        number="${BASH_REMATCH[3]}"
        type="issue"
        alias=$(psm_find_alias_for_repo "$repo")
        if [[ -n "$alias" ]]; then
            IFS='|' read -r _ local_path base <<< "$(psm_get_project "$alias")"
        fi
        echo "issue|${alias:-}|$repo|$number|${local_path:-}|$base|github|${repo}#${number}"
        return 0
    fi

    # Jira direct reference (PROJ-123) - config-validated
    local jira_info
    if jira_info=$(psm_detect_jira_key "$ref"); then
        IFS='|' read -r alias project_key issue_number <<< "$jira_info"
        local project_info
        project_info=$(psm_get_project "$alias")
        if [[ $? -eq 0 ]]; then
            IFS='|' read -r repo local_path base <<< "$project_info"
            echo "issue|${alias}|${repo}|${issue_number}|${local_path}|${base}|jira|${project_key}-${issue_number}"
            return 0
        fi
    fi

    # alias#number format (e.g., omc#123 or mywork#123)
    if [[ "$ref" =~ ^([a-zA-Z][a-zA-Z0-9_-]*)#([0-9]+)$ ]]; then
        alias="${BASH_REMATCH[1]}"
        number="${BASH_REMATCH[2]}"

        local project_info
        project_info=$(psm_get_project "$alias")
        if [[ $? -eq 0 ]]; then
            IFS='|' read -r repo local_path base <<< "$project_info"
            local provider
            provider=$(psm_get_project_provider "$alias")
            local provider_ref=""

            if [[ "$provider" == "jira" ]]; then
                local jira_proj
                jira_proj=$(psm_get_project_jira_project "$alias")
                provider_ref="${jira_proj}-${number}"
            else
                provider_ref="${repo}#${number}"
            fi

            echo "ref|$alias|$repo|$number|$local_path|$base|$provider|$provider_ref"
            return 0
        else
            echo "error|Unknown project alias: $alias|||||||"
            return 1
        fi
    fi

    # owner/repo#number format
    if [[ "$ref" =~ ^([a-zA-Z0-9_-]+)/([a-zA-Z0-9_.-]+)#([0-9]+)$ ]]; then
        repo="${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
        number="${BASH_REMATCH[3]}"
        alias=$(psm_find_alias_for_repo "$repo")
        if [[ -n "$alias" ]]; then
            IFS='|' read -r _ local_path base <<< "$(psm_get_project "$alias")"
        fi
        echo "ref|${alias:-}|$repo|$number|${local_path:-}|$base|github|${repo}#${number}"
        return 0
    fi

    # Just #number (use current repo)
    if [[ "$ref" =~ ^#([0-9]+)$ ]]; then
        number="${BASH_REMATCH[1]}"
        # Detect repo from current directory
        if git rev-parse --git-dir > /dev/null 2>&1; then
            local remote_url=$(git remote get-url origin 2>/dev/null)
            if [[ "$remote_url" =~ github\.com[:/]([^/]+)/([^/.]+) ]]; then
                repo="${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
                local_path=$(git rev-parse --show-toplevel)
                alias=$(psm_find_alias_for_repo "$repo")
            fi
        fi
        echo "ref|${alias:-}|${repo:-}|$number|${local_path:-}|$base|github|${repo:+${repo}#${number}}"
        return 0
    fi

    echo "error|Cannot parse reference: $ref||||||"
    return 1
}

# Find project alias for a given repo
psm_find_alias_for_repo() {
    local target_repo="$1"
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        return 1
    fi

    jq -r --arg r "$target_repo" '.aliases | to_entries[] | select(.value.repo == $r) | .key' "$PSM_PROJECTS" | head -1
}

# Sanitize a string for use in filenames/session names
psm_sanitize() {
    local input="$1"
    # Remove path traversal, convert to lowercase, replace spaces with dashes
    echo "$input" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9-]/-/g' | sed 's/--*/-/g' | head -c 30
}

# Generate a slug from title
psm_slugify() {
    local title="$1"
    local max_len="${2:-30}"
    echo "$title" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | sed 's/^-//' | sed 's/-$//' | head -c "$max_len"
}

# Check if input matches a configured Jira project
# Usage: psm_detect_jira_key "PROJ-123"
# Returns: alias|project_key|issue_number OR exits 1
psm_detect_jira_key() {
    local input="$1"

    # Must match PROJ-123 pattern (uppercase project, dash, digits)
    if [[ ! "$input" =~ ^([A-Z][A-Z0-9]*)-([0-9]+)$ ]]; then
        return 1
    fi

    local project_prefix="${BASH_REMATCH[1]}"
    local issue_number="${BASH_REMATCH[2]}"

    # Verify this project prefix exists in config
    if [[ ! -f "$PSM_PROJECTS" ]]; then
        return 1
    fi

    local matching_alias
    matching_alias=$(jq -r --arg p "$project_prefix" '.aliases | to_entries[] | select(.value.jira_project == $p) | .key' "$PSM_PROJECTS" | head -1)

    if [[ -n "$matching_alias" ]]; then
        echo "${matching_alias}|${project_prefix}|${issue_number}"
        return 0
    fi

    return 1
}

#!/usr/bin/env bash
# PSM Azure DevOps Provider

provider_azure_available() {
    command -v az &> /dev/null
}

provider_azure_detect_ref() {
    local ref="$1"
    [[ "$ref" =~ ^https://dev\.azure\.com/ ]] || \
    [[ "$ref" =~ ^git@ssh\.dev\.azure\.com: ]] || \
    [[ "$ref" =~ \.visualstudio\.com/ ]] || \
    [[ "$ref" =~ ^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#[0-9]+$ ]]
}

provider_azure_fetch_pr() {
    local pr_number="$1"
    local repo="$2"
    az repos pr show --id "$pr_number" --output json 2>/dev/null
}

provider_azure_fetch_issue() {
    local issue_number="$1"
    local repo="$2"
    az boards work-item show --id "$issue_number" --output json 2>/dev/null
}

provider_azure_pr_merged() {
    local pr_number="$1"
    local repo="$2"
    command -v az >/dev/null 2>&1 || return 1
    command -v jq >/dev/null 2>&1 || return 1
    local status
    status=$(az repos pr show --id "$pr_number" --output json 2>/dev/null | jq -r '.status // empty')
    [[ "$status" == "completed" ]]
}

provider_azure_issue_closed() {
    local issue_number="$1"
    local repo="$2"
    command -v az >/dev/null 2>&1 || return 1
    command -v jq >/dev/null 2>&1 || return 1
    local state
    state=$(az boards work-item show --id "$issue_number" --output json 2>/dev/null | jq -r '.fields["System.State"] // empty')
    [[ "$state" == "Closed" || "$state" == "Done" ]]
}

provider_azure_clone_url() {
    local repo="$1"
    # Azure DevOps URLs are complex and org-specific; user should configure directly
    echo ""
    return 1
}

#!/usr/bin/env bash
# PSM Bitbucket Provider

provider_bitbucket_available() {
    command -v curl &> /dev/null
}

provider_bitbucket_detect_ref() {
    local ref="$1"
    # Matches bitbucket.org URLs
    [[ "$ref" =~ ^https://bitbucket\.org/ ]]
}

_bitbucket_curl() {
    local url="$1"
    local -a curl_args=(--fail --silent --show-error --connect-timeout 5 --max-time 20)
    if [[ -n "$BITBUCKET_TOKEN" ]]; then
        curl_args+=(-H "Authorization: Bearer $BITBUCKET_TOKEN")
    elif [[ -n "$BITBUCKET_USERNAME" && -n "$BITBUCKET_APP_PASSWORD" ]]; then
        curl_args+=(-u "$BITBUCKET_USERNAME:$BITBUCKET_APP_PASSWORD")
    fi
    curl "${curl_args[@]}" "$url" 2>/dev/null
}

provider_bitbucket_fetch_pr() {
    local pr_number="$1"
    local repo="$2"
    _bitbucket_curl "https://api.bitbucket.org/2.0/repositories/${repo}/pullrequests/${pr_number}"
}

provider_bitbucket_fetch_issue() {
    local issue_number="$1"
    local repo="$2"
    _bitbucket_curl "https://api.bitbucket.org/2.0/repositories/${repo}/issues/${issue_number}"
}

provider_bitbucket_pr_merged() {
    local pr_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local state
    state=$(provider_bitbucket_fetch_pr "$pr_number" "$repo" | jq -r '.state // empty')
    [[ "$state" == "MERGED" ]]
}

provider_bitbucket_issue_closed() {
    local issue_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local state
    state=$(provider_bitbucket_fetch_issue "$issue_number" "$repo" | jq -r '.state // empty')
    [[ "$state" == "closed" ]]
}

provider_bitbucket_clone_url() {
    local repo="$1"

    # Validate owner/repo format
    if [[ ! "$repo" =~ ^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$ ]]; then
        echo "error|Invalid repository format: $repo" >&2
        return 1
    fi

    echo "https://bitbucket.org/${repo}.git"
}

#!/usr/bin/env bash
# PSM Gitea Provider

provider_gitea_available() {
    command -v tea &> /dev/null || command -v curl &> /dev/null
}

provider_gitea_detect_ref() {
    # Cannot auto-detect self-hosted Gitea instances from URL alone
    return 1
}

_gitea_curl_api() {
    local endpoint="$1"
    local base_url="${GITEA_URL:-https://gitea.com}"
    local -a curl_args=(--fail --silent --show-error --connect-timeout 5 --max-time 20)
    if [[ -n "$GITEA_TOKEN" ]]; then
        curl_args+=(-H "Authorization: token $GITEA_TOKEN")
    fi
    curl "${curl_args[@]}" "${base_url}/api/v1/${endpoint}" 2>/dev/null
}

provider_gitea_fetch_pr() {
    local pr_number="$1"
    local repo="$2"
    # Try tea CLI first, fall back to curl REST API
    if command -v tea &> /dev/null; then
        local result
        result=$(tea pr view "$pr_number" 2>/dev/null)
        if [[ $? -eq 0 && -n "$result" ]]; then
            echo "$result"
            return 0
        fi
    fi
    # Fallback to REST API
    if [[ -n "$GITEA_URL" && -n "$GITEA_TOKEN" ]]; then
        _gitea_curl_api "repos/${repo}/pulls/${pr_number}"
    else
        return 1
    fi
}

provider_gitea_fetch_issue() {
    local issue_number="$1"
    local repo="$2"
    # Try tea CLI first, fall back to curl REST API
    if command -v tea &> /dev/null; then
        local result
        result=$(tea issues view "$issue_number" 2>/dev/null)
        if [[ $? -eq 0 && -n "$result" ]]; then
            echo "$result"
            return 0
        fi
    fi
    # Fallback to REST API
    if [[ -n "$GITEA_URL" && -n "$GITEA_TOKEN" ]]; then
        _gitea_curl_api "repos/${repo}/issues/${issue_number}"
    else
        return 1
    fi
}

provider_gitea_pr_merged() {
    local pr_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local merged
    # Use REST API for structured JSON output
    if [[ -n "$GITEA_URL" && -n "$GITEA_TOKEN" ]]; then
        merged=$(_gitea_curl_api "repos/${repo}/pulls/${pr_number}" | jq -r '.merged // empty')
        [[ "$merged" == "true" ]]
    else
        return 1
    fi
}

provider_gitea_issue_closed() {
    local issue_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local state
    # Use REST API for structured JSON output
    if [[ -n "$GITEA_URL" && -n "$GITEA_TOKEN" ]]; then
        state=$(_gitea_curl_api "repos/${repo}/issues/${issue_number}" | jq -r '.state // empty')
        [[ "$state" == "closed" ]]
    else
        return 1
    fi
}

provider_gitea_clone_url() {
    local repo="$1"

    # Validate owner/repo format
    if [[ ! "$repo" =~ ^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$ ]]; then
        echo "error|Invalid repository format: $repo" >&2
        return 1
    fi

    echo "${GITEA_URL:-https://gitea.com}/${repo}.git"
}

#!/usr/bin/env bash
# PSM GitHub Provider

provider_github_available() {
    command -v gh &> /dev/null
}

provider_github_detect_ref() {
    local ref="$1"
    # Matches github URLs or owner/repo#num patterns
    [[ "$ref" =~ ^https://github\.com/ ]] || [[ "$ref" =~ ^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+#[0-9]+$ ]]
}

provider_github_fetch_pr() {
    local pr_number="$1"
    local repo="$2"
    gh pr view "$pr_number" --repo "$repo" --json number,title,author,headRefName,baseRefName,body,files,url 2>/dev/null
}

provider_github_fetch_issue() {
    local issue_number="$1"
    local repo="$2"
    gh issue view "$issue_number" --repo "$repo" --json number,title,body,labels,url 2>/dev/null
}

provider_github_pr_merged() {
    local pr_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local merged
    merged=$(gh pr view "$pr_number" --repo "$repo" --json merged 2>/dev/null | jq -r '.merged // empty')
    [[ "$merged" == "true" ]]
}

provider_github_issue_closed() {
    local issue_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local closed
    closed=$(gh issue view "$issue_number" --repo "$repo" --json closed 2>/dev/null | jq -r '.closed // empty')
    [[ "$closed" == "true" ]]
}

provider_github_clone_url() {
    local repo="$1"

    # Validate owner/repo format
    if [[ ! "$repo" =~ ^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$ ]]; then
        echo "error|Invalid repository format: $repo" >&2
        return 1
    fi

    echo "https://github.com/${repo}.git"
}

#!/usr/bin/env bash
# PSM GitLab Provider

provider_gitlab_available() {
    command -v glab &> /dev/null
}

provider_gitlab_detect_ref() {
    local ref="$1"
    # Matches gitlab URLs or owner/repo!num patterns (GitLab uses ! for MRs)
    [[ "$ref" =~ ^https://gitlab\. ]] || [[ "$ref" =~ ^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+![0-9]+$ ]]
}

provider_gitlab_fetch_pr() {
    local mr_number="$1"
    local repo="$2"
    glab mr view "$mr_number" --repo "$repo" --output json 2>/dev/null
}

provider_gitlab_fetch_issue() {
    local issue_number="$1"
    local repo="$2"
    glab issue view "$issue_number" --repo "$repo" --output json 2>/dev/null
}

provider_gitlab_pr_merged() {
    local pr_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local merged_at
    merged_at=$(glab mr view "$pr_number" --repo "$repo" --output json 2>/dev/null | jq -r '.merged_at // empty')
    [[ -n "$merged_at" && "$merged_at" != "null" ]]
}

provider_gitlab_issue_closed() {
    local issue_number="$1"
    local repo="$2"
    command -v jq >/dev/null 2>&1 || return 1
    local state
    state=$(glab issue view "$issue_number" --repo "$repo" --output json 2>/dev/null | jq -r '.state // empty')
    [[ "$state" == "closed" ]]
}

provider_gitlab_clone_url() {
    local repo="$1"

    # Validate owner/repo format
    if [[ ! "$repo" =~ ^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$ ]]; then
        echo "error|Invalid repository format: $repo" >&2
        return 1
    fi

    echo "https://gitlab.com/${repo}.git"
}

#!/usr/bin/env bash
# PSM Provider Interface
# Each provider implements: _available, _detect_ref, _fetch_issue, _issue_closed,
#                          _fetch_pr (optional), _pr_merged (optional), _clone_url

# List available providers
provider_list() {
    echo "github jira"
}

# Allowlist of valid providers
readonly VALID_PROVIDERS="github jira"

# Check if a provider is available (CLI installed)
# Usage: provider_available "github"
provider_available() {
    local provider="$1"

    # Validate provider against allowlist
    if ! echo "$VALID_PROVIDERS" | grep -qw "$provider"; then
        echo "error|Invalid provider: $provider" >&2
        return 1
    fi

    "provider_${provider}_available"
}

# Dispatch to provider function
# Usage: provider_call "github" "fetch_issue" "123" "owner/repo"
provider_call() {
    local provider="$1"
    local func="$2"
    shift 2

    # Validate provider against allowlist
    if ! echo "$VALID_PROVIDERS" | grep -qw "$provider"; then
        echo "error|Invalid provider: $provider" >&2
        return 1
    fi

    # Validate function name (alphanumeric and underscore only)
    if [[ ! "$func" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
        echo "error|Invalid function name: $func" >&2
        return 1
    fi

    "provider_${provider}_${func}" "$@"
}

# Detect provider from reference (with config validation)
# Usage: provider_detect_from_ref "PROJ-123"
# Returns: provider name or empty
provider_detect_from_ref() {
    local ref="$1"

    # Check Jira pattern first (config-validated)
    if psm_detect_jira_key "$ref" >/dev/null 2>&1; then
        echo "jira"
        return 0
    fi

    # GitHub URL patterns
    if [[ "$ref" =~ ^https://github\.com/ ]]; then
        echo "github"
        return 0
    fi

    # owner/repo#num pattern -> GitHub
    if [[ "$ref" =~ ^[a-zA-Z0-9_-]+/[a-zA-Z0-9_.-]+#[0-9]+$ ]]; then
        echo "github"
        return 0
    fi

    # Default
    echo "github"
}

#!/usr/bin/env bash
# PSM Jira Provider
# Uses `jira` CLI (https://github.com/ankitpokhrel/jira-cli)

provider_jira_available() {
    command -v jira &> /dev/null
}

provider_jira_detect_ref() {
    local ref="$1"
    # Config-validated detection only
    psm_detect_jira_key "$ref" >/dev/null 2>&1
}

provider_jira_fetch_issue() {
    local issue_key="$1"  # e.g., "PROJ-123"
    # Note: second arg (repo) is ignored for Jira
    jira issue view "$issue_key" --output json 2>/dev/null
}

provider_jira_issue_closed() {
    local issue_key="$1"
    local status_category
    status_category=$(jira issue view "$issue_key" --output json 2>/dev/null | jq -r '.fields.status.statusCategory.key')
    # Jira status categories: "new", "indeterminate", "done"
    [[ "$status_category" == "done" ]]
}

# Jira has no PRs - return error
provider_jira_fetch_pr() {
    echo '{"error": "Jira does not support pull requests"}' >&2
    return 1
}

provider_jira_pr_merged() {
    return 1  # Always false - Jira has no PRs
}

provider_jira_clone_url() {
    local alias="$1"
    # For Jira, we need to get clone_url from config
    # First try explicit clone_url, then fall back to repo as GitHub
    local clone_url
    clone_url=$(psm_get_project_clone_url "$alias")
    if [[ -n "$clone_url" ]]; then
        echo "$clone_url"
        return 0
    fi

    local repo
    repo=$(psm_get_project_repo "$alias")
    if [[ -n "$repo" ]]; then
        echo "https://github.com/${repo}.git"
        return 0
    fi

    echo "error: No clone_url or repo configured for alias '$alias'" >&2
    return 1
}

# Parse Jira reference into components
# Input: "PROJ-123" or "mywork#123"
# Output: Extended format for session creation
provider_jira_parse_ref() {
    local ref="$1"
    local jira_info

    # Try direct PROJ-123 pattern
    if jira_info=$(psm_detect_jira_key "$ref"); then
        IFS='|' read -r alias project_key issue_number <<< "$jira_info"
        local project_info
        project_info=$(psm_get_project "$alias")
        IFS='|' read -r repo local_path base <<< "$project_info"
        echo "issue|${alias}|${repo}|${issue_number}|${local_path}|${base}|jira|${project_key}-${issue_number}"
        return 0
    fi

    return 1
}

#!/usr/bin/env bash
# PSM Session Registry Management

# Lock file for atomic registry operations
PSM_LOCK_FILE="${PSM_DATA_DIR:-.psm}/.psm-lock"

# Wrapper for atomic operations with file locking
# Usage: psm_with_lock <command> [args...]
psm_with_lock() {
    local timeout="${PSM_LOCK_TIMEOUT:-5}"
    (
        flock -w "$timeout" 200 || {
            echo "error|Failed to acquire lock after ${timeout}s" >&2
            return 1
        }
        "$@"
    ) 200>"$PSM_LOCK_FILE"
}

# Internal: Add session to registry (must be called via psm_with_lock)
_psm_add_session_impl() {
    local id="$1"
    local type="$2"
    local project="$3"
    local ref="$4"
    local branch="$5"
    local base="$6"
    local tmux_session="$7"
    local worktree="$8"
    local source_repo="$9"
    local metadata="${10:-{}}"
    local provider="${11:-github}"
    local provider_ref="${12:-}"

    local now=$(date -Iseconds)

    local tmp=$(mktemp)
    jq --arg id "$id" \
       --arg type "$type" \
       --arg project "$project" \
       --arg ref "$ref" \
       --arg branch "$branch" \
       --arg base "$base" \
       --arg tmux "$tmux_session" \
       --arg worktree "$worktree" \
       --arg source "$source_repo" \
       --arg now "$now" \
       --arg provider "$provider" \
       --arg provider_ref "$provider_ref" \
       --argjson meta "$metadata" \
       '.sessions[$id] = {
          "id": $id,
          "type": $type,
          "project": $project,
          "ref": $ref,
          "branch": $branch,
          "base": $base,
          "tmux": $tmux,
          "worktree": $worktree,
          "source_repo": $source,
          "created_at": $now,
          "last_accessed": $now,
          "state": "active",
          "provider": $provider,
          "provider_ref": $provider_ref,
          "metadata": $meta
        } | .stats.total_created += 1' \
       "$PSM_SESSIONS" > "$tmp" && mv "$tmp" "$PSM_SESSIONS"
}

# Add session to registry (with file locking)
# Usage: psm_add_session <id> <type> <project> <ref> <branch> <base> <tmux> <worktree> <source_repo> <metadata_json> [provider] [provider_ref]
psm_add_session() {
    psm_with_lock _psm_add_session_impl "$@"
}

# Get session by ID
# Usage: psm_get_session <id>
psm_get_session() {
    local id="$1"
    jq -r --arg i "$id" '.sessions[$i] // empty' "$PSM_SESSIONS"
}

# Internal: Update session state (must be called via psm_with_lock)
_psm_update_session_state_impl() {
    local id="$1"
    local state="$2"
    local now=$(date -Iseconds)

    local tmp=$(mktemp)
    jq --arg id "$id" \
       --arg state "$state" \
       --arg now "$now" \
       '.sessions[$id].state = $state | .sessions[$id].last_accessed = $now' \
       "$PSM_SESSIONS" > "$tmp" && mv "$tmp" "$PSM_SESSIONS"
}

# Update session state (with file locking)
# Usage: psm_update_session_state <id> <state>
psm_update_session_state() {
    psm_with_lock _psm_update_session_state_impl "$@"
}

# Internal: Remove session from registry (must be called via psm_with_lock)
_psm_remove_session_impl() {
    local id="$1"

    local tmp=$(mktemp)
    jq --arg id "$id" \
       'del(.sessions[$id]) | .stats.total_cleaned += 1' \
       "$PSM_SESSIONS" > "$tmp" && mv "$tmp" "$PSM_SESSIONS"
}

# Remove session from registry (with file locking)
# Usage: psm_remove_session <id>
psm_remove_session() {
    psm_with_lock _psm_remove_session_impl "$@"
}

# List all sessions
# Usage: psm_list_sessions [project]
psm_list_sessions() {
    local project="$1"

    if [[ -n "$project" ]]; then
        jq -r --arg p "$project" '.sessions | to_entries[] | select(.value.project == $p) | .value | "\(.id)|\(.type)|\(.state)|\(.worktree)"' "$PSM_SESSIONS"
    else
        jq -r '.sessions | to_entries[] | .value | "\(.id)|\(.type)|\(.state)|\(.worktree)"' "$PSM_SESSIONS"
    fi
}

# Get sessions by state
psm_get_sessions_by_state() {
    local state="$1"
    jq -r --arg s "$state" '.sessions | to_entries[] | select(.value.state == $s) | .value.id' "$PSM_SESSIONS"
}

# Get session count
psm_session_count() {
    jq -r '.sessions | length' "$PSM_SESSIONS"
}

# Write session metadata file in worktree
# Usage: psm_write_session_metadata <worktree_path> <session_json>
psm_write_session_metadata() {
    local worktree_path="$1"
    local session_json="$2"

    echo "$session_json" > "${worktree_path}/.psm-session.json"
}

# Read session metadata from worktree
psm_read_session_metadata() {
    local worktree_path="$1"
    local meta_file="${worktree_path}/.psm-session.json"

    if [[ -f "$meta_file" ]]; then
        cat "$meta_file"
    fi
}

# Get all session IDs for cleanup check
psm_get_review_sessions() {
    jq -r '.sessions | to_entries[] | select(.value.type == "review" and (.value.state // "active") == "active") | "\(.value.id)|\(.value.metadata.pr_number // empty)|\(.value.project)"' "$PSM_SESSIONS"
}

psm_get_fix_sessions() {
    jq -r '.sessions | to_entries[] | select(.value.type == "fix" and (.value.state // "active") == "active") | "\(.value.id)|\(.value.metadata.issue_number // empty)|\(.value.project)"' "$PSM_SESSIONS"
}

#!/usr/bin/env bash
# PSM Tmux Session Management

# Check if tmux is available
psm_has_tmux() {
    command -v tmux &> /dev/null
}

# Create a tmux session
# Usage: psm_create_tmux_session <session_name> <working_dir>
psm_create_tmux_session() {
    local session_name="$1"
    local working_dir="$2"

    if ! psm_has_tmux; then
        echo "error|tmux not found"
        return 1
    fi

    # Check if session already exists
    if tmux has-session -t "$session_name" 2>/dev/null; then
        echo "exists|$session_name"
        return 1
    fi

    # Create detached session
    tmux new-session -d -s "$session_name" -c "$working_dir" 2>/dev/null || {
        echo "error|Failed to create tmux session"
        return 1
    }

    echo "created|$session_name"
    return 0
}

# Launch Claude Code in tmux session, optionally injecting either a context-file
# trigger prompt or a literal initial prompt.
# Usage: psm_launch_claude <session_name> [initial_context]
# initial_context may be either:
#   - a path relative to the worktree root (e.g. .psm/review.md), or
#   - a literal prompt string to send after Claude boots.
#
# Passes --dangerously-skip-permissions so the session does not stall on
# directory-trust or repeated tool-approval prompts (issue #2508).
# Set PSM_CLAUDE_STARTUP_DELAY (default: 5s) to tune literal-prompt delivery.
psm_launch_claude() {
    local session_name="$1"
    local initial_context="${2:-}"

    if ! tmux has-session -t "$session_name" 2>/dev/null; then
        echo "error|Session not found: $session_name"
        return 1
    fi

    # --dangerously-skip-permissions bypasses both the directory-trust prompt and
    # every per-tool approval prompt. Without this flag, unattended PSM sessions
    # can block indefinitely on the first tool call (issue #2508).
    tmux send-keys -t "$session_name" "claude --dangerously-skip-permissions" Enter

    if [[ -n "$initial_context" ]]; then
        local session_path=""
        session_path=$(tmux display-message -p -t "$session_name" '#{pane_current_path}' 2>/dev/null || true)

        # If the second arg resolves to a file in the worktree, preserve the
        # existing context-file flow. Otherwise treat it as a literal prompt.
        if [[ -n "$session_path" && -f "$session_path/$initial_context" ]]; then
            psm_inject_prompt "$session_name" "$initial_context"
        else
            local startup_delay="${PSM_CLAUDE_STARTUP_DELAY:-5}"
            (
                sleep "$startup_delay"
                tmux send-keys -t "$session_name" -l -- "$initial_context" 2>/dev/null || true
                tmux send-keys -t "$session_name" Enter 2>/dev/null || true
            ) &
        fi
    fi

    echo "launched|$session_name"
    return 0
}

# Render a PSM template file by substituting {{KEY}} placeholders.
# Usage: psm_render_template <template_file> [KEY=VALUE ...]
# Outputs rendered content to stdout; returns 1 if template not found.
psm_render_template() {
    local template_file="$1"
    shift

    if [[ ! -f "$template_file" ]]; then
        echo "error|Template not found: $template_file" >&2
        return 1
    fi

    local content
    content=$(cat "$template_file")

    for assignment in "$@"; do
        local key="${assignment%%=*}"
        local value="${assignment#*=}"
        # Bash parameter expansion handles multiline values safely
        content="${content//\{\{${key}\}\}/$value}"
    done

    printf '%s\n' "$content"
}

# Returns 0 if the captured pane text shows Claude's interactive input prompt.
# Matches '>' (standard prompt) or '?' (trust prompt) as the sole content of a line.
# Usage: _psm_pane_has_claude_prompt <pane_text>
_psm_pane_has_claude_prompt() {
    local pane_text="$1"
    printf '%s' "$pane_text" | grep -qE '^[[:space:]]*(>|\?)[[:space:]]*$'
}

# Poll the tmux pane until Claude's REPL prompt appears.
# Usage: psm_wait_for_claude_prompt <session_name> [max_seconds]
# Returns 0 when prompt detected; 1 on timeout.
psm_wait_for_claude_prompt() {
    local session_name="$1"
    local max_wait="${2:-30}"
    local waited=0

    while [[ $waited -lt $max_wait ]]; do
        local pane_content
        pane_content=$(tmux capture-pane -t "$session_name" -p 2>/dev/null) || return 1
        if _psm_pane_has_claude_prompt "$pane_content"; then
            return 0
        fi
        sleep 1
        (( waited++ )) || true
    done

    return 1
}

# Wait for Claude's REPL to be ready then inject a context-file trigger prompt.
# Non-fatal: warns on timeout but does not fail the session creation.
# Usage: psm_inject_prompt <session_name> <context_file_relative_path>
psm_inject_prompt() {
    local session_name="$1"
    local context_file="$2"

    if ! psm_wait_for_claude_prompt "$session_name"; then
        echo "warn|Timed out waiting for Claude prompt; task context not injected" >&2
        return 0
    fi

    local trigger="Read ${context_file} for full task context, then begin."

    # Use literal mode (-l) to prevent tmux from interpreting key names in the text
    tmux send-keys -t "$session_name" -l -- "$trigger"
    sleep 0.15
    tmux send-keys -t "$session_name" Enter

    return 0
}

# Kill a tmux session
# Usage: psm_kill_tmux_session <session_name>
psm_kill_tmux_session() {
    local session_name="$1"

    if ! tmux has-session -t "$session_name" 2>/dev/null; then
        echo "not_found|$session_name"
        return 0
    fi

    tmux kill-session -t "$session_name" 2>/dev/null || {
        echo "error|Failed to kill session"
        return 1
    }

    echo "killed|$session_name"
    return 0
}

# List all PSM tmux sessions
psm_list_tmux_sessions() {
    if ! psm_has_tmux; then
        return 0
    fi

    tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}" 2>/dev/null | grep "^psm:" || true
}

# Check if a tmux session exists
# Usage: psm_tmux_session_exists <session_name>
psm_tmux_session_exists() {
    local session_name="$1"
    tmux has-session -t "$session_name" 2>/dev/null
}

# Get current tmux session name
psm_current_tmux_session() {
    if [[ -n "$TMUX" ]]; then
        tmux display-message -p "#{session_name}" 2>/dev/null
    fi
}

# Generate tmux session name
# Usage: psm_tmux_session_name <alias> <type> <id>
psm_tmux_session_name() {
    local alias="$1"
    local type="$2"
    local id="$3"

    echo "psm:${alias}:${type}-${id}"
}

#!/usr/bin/env bash
# PSM Worktree Management

# Validate worktree path is under PSM worktree root before deletion
# Returns 0 if valid, 1 if invalid
# Usage: validate_worktree_path <path>
validate_worktree_path() {
    local path="$1"
    local worktree_root
    worktree_root=$(psm_get_worktree_root 2>/dev/null) || return 1

    # Path must exist and be a directory
    if [[ ! -d "$path" ]]; then
        return 1
    fi

    # Resolve to absolute paths for comparison
    local abs_path abs_root
    abs_path=$(cd "$path" 2>/dev/null && pwd) || return 1
    abs_root=$(cd "$worktree_root" 2>/dev/null && pwd) || return 1

    # Check path is under root and doesn't contain ..
    if [[ "$abs_path" != "$abs_root"/* ]] || [[ "$path" == *".."* ]]; then
        echo "error|Invalid worktree path: not under PSM root" >&2
        return 1
    fi
    return 0
}

# Best-effort dependency bootstrap for clean PR review worktrees.
# Reuses the source repo node_modules only when package.json matches exactly.
# This keeps focused test commands like `npm run test:run -- ...` usable
# without forcing a full install in every review worktree.
psm_bootstrap_review_dependencies() {
    local local_repo="$1"
    local worktree_path="$2"

    local source_package_json="${local_repo}/package.json"
    local target_package_json="${worktree_path}/package.json"
    local source_node_modules="${local_repo}/node_modules"
    local target_node_modules="${worktree_path}/node_modules"

    [[ -f "$source_package_json" ]] || return 0
    [[ -f "$target_package_json" ]] || return 0
    [[ -d "$source_node_modules" ]] || return 0
    [[ ! -e "$target_node_modules" ]] || return 0

    cmp -s "$source_package_json" "$target_package_json" || return 0

    ln -s "$source_node_modules" "$target_node_modules" 2>/dev/null || true
    return 0
}

# Create a worktree for PR review
# Usage: psm_create_pr_worktree <local_repo> <alias> <pr_number> <pr_branch>
psm_create_pr_worktree() {
    local local_repo="$1"
    local alias="$2"
    local pr_number="$3"
    local pr_branch="$4"

    local worktree_root=$(psm_get_worktree_root)
    local worktree_path="${worktree_root}/${alias}/pr-${pr_number}"

    # Check if worktree already exists
    if [[ -d "$worktree_path" ]]; then
        echo "exists|$worktree_path"
        return 1
    fi

    # Ensure parent directory exists
    mkdir -p "${worktree_root}/${alias}"

    # Fetch the PR branch
    cd "$local_repo" || return 1
    git fetch origin "pull/${pr_number}/head:psm-pr-${pr_number}-review" 2>/dev/null || {
        echo "error|Failed to fetch PR #${pr_number}"
        return 1
    }

    # Create worktree
    git worktree add "$worktree_path" "psm-pr-${pr_number}-review" 2>/dev/null || {
        echo "error|Failed to create worktree"
        return 1
    }

    psm_bootstrap_review_dependencies "$local_repo" "$worktree_path"

    echo "created|$worktree_path"
    return 0
}

# Create a worktree for issue fix
# Usage: psm_create_issue_worktree <local_repo> <alias> <issue_number> <slug> <base_branch>
psm_create_issue_worktree() {
    local local_repo="$1"
    local alias="$2"
    local issue_number="$3"
    local slug="$4"
    local base_branch="${5:-main}"

    local worktree_root=$(psm_get_worktree_root)
    local worktree_path="${worktree_root}/${alias}/issue-${issue_number}"
    local branch_name="fix/${issue_number}-${slug}"

    # Check if worktree already exists
    if [[ -d "$worktree_path" ]]; then
        echo "exists|$worktree_path|$branch_name"
        return 1
    fi

    mkdir -p "${worktree_root}/${alias}"

    cd "$local_repo" || return 1

    # Fetch latest from origin
    git fetch origin "$base_branch" 2>/dev/null || {
        echo "error|Failed to fetch $base_branch"
        return 1
    }

    # Create and checkout new branch
    git branch "$branch_name" "origin/$base_branch" 2>/dev/null || {
        # Branch might already exist
        true
    }

    # Create worktree
    git worktree add "$worktree_path" "$branch_name" 2>/dev/null || {
        echo "error|Failed to create worktree"
        return 1
    }

    echo "created|$worktree_path|$branch_name"
    return 0
}

# Create a worktree for feature development
# Usage: psm_create_feature_worktree <local_repo> <alias> <feature_name> <base_branch>
psm_create_feature_worktree() {
    local local_repo="$1"
    local alias="$2"
    local feature_name="$3"
    local base_branch="${4:-main}"

    local worktree_root=$(psm_get_worktree_root)
    local safe_name=$(psm_sanitize "$feature_name")
    local worktree_path="${worktree_root}/${alias}/feat-${safe_name}"
    local branch_name="feature/${safe_name}"

    # Check if worktree already exists
    if [[ -d "$worktree_path" ]]; then
        echo "exists|$worktree_path|$branch_name"
        return 1
    fi

    mkdir -p "${worktree_root}/${alias}"

    cd "$local_repo" || return 1

    # Fetch latest
    git fetch origin "$base_branch" 2>/dev/null || {
        echo "error|Failed to fetch $base_branch"
        return 1
    }

    # Create branch
    git branch "$branch_name" "origin/$base_branch" 2>/dev/null || true

    # Create worktree
    git worktree add "$worktree_path" "$branch_name" 2>/dev/null || {
        echo "error|Failed to create worktree"
        return 1
    }

    echo "created|$worktree_path|$branch_name"
    return 0
}

# Remove a worktree
# Usage: psm_remove_worktree <local_repo> <worktree_path>
psm_remove_worktree() {
    local local_repo="$1"
    local worktree_path="$2"

    if [[ ! -d "$worktree_path" ]]; then
        echo "not_found|$worktree_path"
        return 1
    fi

    # Check for uncommitted changes
    if [[ -d "$worktree_path/.git" ]] || [[ -f "$worktree_path/.git" ]]; then
        cd "$worktree_path" || return 1
        if [[ -n $(git status --porcelain 2>/dev/null) ]]; then
            echo "dirty|$worktree_path"
            return 1
        fi
    fi

    cd "$local_repo" || return 1

    # Validate path is under PSM worktree root before any deletion
    if validate_worktree_path "$worktree_path"; then
        git worktree remove "$worktree_path" --force 2>/dev/null || {
            # Force remove the directory if git worktree remove fails
            rm -rf "$worktree_path"
        }
    else
        echo "error|Refusing to delete path outside worktree root: $worktree_path" >&2
        return 1
    fi

    echo "removed|$worktree_path"
    return 0
}

# List all PSM worktrees
psm_list_worktrees() {
    local worktree_root=$(psm_get_worktree_root)

    if [[ ! -d "$worktree_root" ]]; then
        return 0
    fi

    find "$worktree_root" -mindepth 2 -maxdepth 2 -type d 2>/dev/null | while read -r dir; do
        local alias=$(basename "$(dirname "$dir")")
        local name=$(basename "$dir")
        echo "${alias}:${name}|${dir}"
    done
}

#!/usr/bin/env bash
# Project Session Manager (PSM) - Main Script
# Usage: psm.sh <command> [args...]

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Source library files
source "$SCRIPT_DIR/lib/config.sh"
source "$SCRIPT_DIR/lib/parse.sh"
source "$SCRIPT_DIR/lib/worktree.sh"
source "$SCRIPT_DIR/lib/tmux.sh"
source "$SCRIPT_DIR/lib/session.sh"

# Source provider files
source "$SCRIPT_DIR/lib/providers/interface.sh"
source "$SCRIPT_DIR/lib/providers/github.sh"
source "$SCRIPT_DIR/lib/providers/jira.sh"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Logging
log_info() { echo -e "${BLUE}[PSM]${NC} $*"; }
log_success() { echo -e "${GREEN}[PSM]${NC} $*"; }
log_warn() { echo -e "${YELLOW}[PSM]${NC} $*"; }
log_error() { echo -e "${RED}[PSM]${NC} $*" >&2; }

# Check dependencies
check_dependencies() {
    local missing=()

    if ! command -v git &> /dev/null; then
        missing+=("git")
    fi

    if ! command -v jq &> /dev/null; then
        missing+=("jq")
    fi

    # Note: gh and jira are checked per-operation, not globally
    # This allows users without gh to still use Jira, and vice versa

    if [[ ${#missing[@]} -gt 0 ]]; then
        log_error "Missing required dependencies: ${missing[*]}"
        log_info "Install with:"
        log_info "  Ubuntu/Debian: sudo apt install git jq"
        log_info "  macOS: brew install git jq"
        exit 1
    fi

    # tmux is optional but warn if missing
    if ! command -v tmux &> /dev/null; then
        log_warn "tmux not found. Sessions will be created without tmux."
    fi
}

# Print usage
usage() {
    cat << 'EOF'
Project Session Manager (PSM) - Isolated dev environments

Usage: psm <command> [args...]

Commands:
  review <ref>           Create PR review session
  fix <ref>              Create issue fix session
  feature <proj> <name>  Create feature development session
  list [project]         List active sessions
  attach <session>       Attach to existing session
  kill <session>         Kill and cleanup session
  cleanup [--force]      Clean merged PRs and closed issues
  status                 Show current session info

Reference formats:
  omc#123               Project alias + number
  owner/repo#123        Full GitHub reference
  https://...           GitHub URL
  #123                  Number only (uses current repo)

Examples:
  psm review omc#123
  psm fix Yeachan-Heo/oh-my-claudecode#42
  psm feature omc add-webhooks
  psm list
  psm attach omc:pr-123
  psm kill omc:pr-123
  psm cleanup
EOF
}

# Command: review
cmd_review() {
    local ref="$1"
    local no_claude="${2:-false}"
    local no_tmux="${3:-false}"

    log_info "Parsing reference: $ref"

    # Parse reference
    local parsed
    parsed=$(psm_parse_ref "$ref")
    if [[ $? -ne 0 ]] || [[ "$parsed" == error* ]]; then
        log_error "Failed to parse reference: $ref"
        return 1
    fi

    IFS='|' read -r type alias repo pr_number local_path base provider provider_ref <<< "$parsed"

    # Provider guard: Jira doesn't have PRs
    if [[ "$provider" == "jira" ]]; then
        log_error "Jira issues cannot be 'reviewed' - Jira has no PR concept."
        log_info "Use 'psm fix $ref' to work on a Jira issue instead."
        log_info "Jira integration supports: fix, feature"
        return 1
    fi

    # Check GitHub CLI availability
    if ! provider_github_available; then
        log_error "GitHub CLI (gh) not found. Install: brew install gh"
        return 1
    fi

    if [[ -z "$repo" ]]; then
        log_error "Could not determine repository"
        return 1
    fi

    log_info "Fetching PR #${pr_number} from ${repo}..."

    # Fetch PR info
    local pr_info
    pr_info=$(provider_call "github" fetch_pr "$pr_number" "$repo") || {
        log_error "Failed to fetch PR #${pr_number}. Check if the PR exists and you have access."
        return 1
    }

    local pr_title=$(echo "$pr_info" | jq -r '.title')
    local pr_author=$(echo "$pr_info" | jq -r '.author.login')
    local head_branch=$(echo "$pr_info" | jq -r '.headRefName')
    local base_branch=$(echo "$pr_info" | jq -r '.baseRefName')
    local pr_url=$(echo "$pr_info" | jq -r '.url')
    local pr_body=$(echo "$pr_info" | jq -r '.body // ""')
    local changed_files=$(echo "$pr_info" | jq -r '.files[]?.path // empty' 2>/dev/null | head -50 || true)

    log_info "PR: #${pr_number} - ${pr_title}"
    log_info "Author: @${pr_author}"
    log_info "Branch: ${head_branch} -> ${base_branch}"

    # Determine alias if not set
    if [[ -z "$alias" ]]; then
        alias=$(echo "$repo" | tr '/' '-')
    fi

    # Determine local path
    if [[ -z "$local_path" || ! -d "$local_path" ]]; then
        # Clone if needed
        local_path="${HOME}/Workspace/$(basename "$repo")"
        if [[ ! -d "$local_path" ]]; then
            log_info "Cloning repository to $local_path..."
            local clone_url
            clone_url=$(provider_call "github" clone_url "$repo")
            git clone "$clone_url" "$local_path" || {
                log_error "Failed to clone repository"
                return 1
            }
        fi
    fi

    # Create worktree
    log_info "Creating worktree..."
    local worktree_result
    worktree_result=$(psm_create_pr_worktree "$local_path" "$alias" "$pr_number" "$head_branch")

    local worktree_status
    local worktree_path
    IFS='|' read -r worktree_status worktree_path <<< "$worktree_result"

    if [[ "$worktree_status" == "exists" ]]; then
        log_warn "Worktree already exists at $worktree_path"
        log_info "Use 'psm attach ${alias}:pr-${pr_number}' to attach"
        return 0
    elif [[ "$worktree_status" == "error" ]]; then
        log_error "Failed to create worktree: $worktree_path"
        return 1
    fi

    log_success "Worktree created at $worktree_path"

    # Render PR review context file into the worktree so Claude starts with full task context
    local context_rel=".psm/review.md"
    local context_file="${worktree_path}/${context_rel}"
    mkdir -p "$(dirname "$context_file")"
    if ! psm_render_template "$SCRIPT_DIR/templates/pr-review.md" \
            "PR_NUMBER=${pr_number}" \
            "PR_TITLE=${pr_title}" \
            "PR_AUTHOR=${pr_author}" \
            "PR_URL=${pr_url}" \
            "HEAD_BRANCH=${head_branch}" \
            "BASE_BRANCH=${base_branch}" \
            "PR_BODY=${pr_body}" \
            "CHANGED_FILES=${changed_files}" \
            > "$context_file"; then
        log_warn "Failed to render review template; Claude will start without task context"
        context_rel=""
    fi

    # Create tmux session
    local session_name="psm:${alias}:pr-${pr_number}"
    local session_id="${alias}:pr-${pr_number}"

    if [[ "$no_tmux" != "true" ]]; then
        log_info "Creating tmux session..."
        local tmux_result
        tmux_result=$(psm_create_tmux_session "$session_name" "$worktree_path")

        local tmux_status
        IFS='|' read -r tmux_status _ <<< "$tmux_result"

        if [[ "$tmux_status" == "error" ]]; then
            log_warn "Could not create tmux session. Continuing without tmux."
        elif [[ "$tmux_status" == "exists" ]]; then
            log_warn "Tmux session already exists"
        else
            log_success "Tmux session created: $session_name"

            # Launch Claude Code with review context so it starts on the PR task
            if [[ "$no_claude" != "true" ]]; then
                log_info "Launching Claude Code..."
                psm_launch_claude "$session_name" "$context_rel"
            fi
        fi
    fi

    # Create session metadata
    local metadata
    metadata=$(jq -n \
      --argjson pr_number "$pr_number" \
      --arg pr_title "$pr_title" \
      --arg pr_author "$pr_author" \
      --arg pr_url "$pr_url" \
      '{pr_number: $pr_number, pr_title: $pr_title, pr_author: $pr_author, pr_url: $pr_url}')

    # Add to registry
    psm_add_session "$session_id" "review" "$alias" "pr-${pr_number}" "$head_branch" "$base_branch" "$session_name" "$worktree_path" "$local_path" "$metadata" "github" "${repo}#${pr_number}"

    # Output summary
    echo ""
    log_success "Session ready!"
    echo ""
    echo "  ID:       $session_id"
    echo "  Type:     review"
    echo "  PR:       #${pr_number} - ${pr_title}"
    echo "  Worktree: $worktree_path"
    echo "  Tmux:     $session_name"
    echo ""
    echo "Commands:"
    echo "  Attach:   tmux attach -t $session_name"
    echo "  Kill:     psm kill $session_id"
    echo "  Cleanup:  psm cleanup"
    echo ""
}

# Command: fix
cmd_fix() {
    local ref="$1"
    local no_claude="${2:-false}"

    log_info "Parsing reference: $ref"

    local parsed
    parsed=$(psm_parse_ref "$ref")
    if [[ $? -ne 0 ]] || [[ "$parsed" == error* ]]; then
        log_error "Failed to parse reference: $ref"
        return 1
    fi

    IFS='|' read -r type alias repo issue_number local_path base provider provider_ref <<< "$parsed"

    # Check provider CLI availability
    if [[ "$provider" == "jira" ]]; then
        if ! provider_jira_available; then
            log_error "Jira CLI not found. Install: brew install ankitpokhrel/jira-cli/jira-cli"
            return 1
        fi
    else
        if ! provider_github_available; then
            log_error "GitHub CLI (gh) not found. Install: brew install gh"
            return 1
        fi
    fi

    if [[ -z "$repo" && "$provider" != "jira" ]]; then
        log_error "Could not determine repository"
        return 1
    fi

    log_info "Fetching issue #${issue_number}..."

    # Fetch issue info
    local issue_info
    local issue_body="" issue_labels=""
    if [[ "$provider" == "jira" ]]; then
        issue_info=$(provider_call "jira" fetch_issue "$provider_ref") || {
            log_error "Failed to fetch Jira issue ${provider_ref}"
            return 1
        }
        local issue_title=$(echo "$issue_info" | jq -r '.fields.summary')
        local issue_url=$(echo "$issue_info" | jq -r '.self // empty')
        issue_body=$(echo "$issue_info" | jq -r '.fields.description // ""')
    else
        issue_info=$(provider_call "github" fetch_issue "$issue_number" "$repo") || {
            log_error "Failed to fetch issue #${issue_number}"
            return 1
        }
        local issue_title=$(echo "$issue_info" | jq -r '.title')
        local issue_url=$(echo "$issue_info" | jq -r '.url')
        issue_body=$(echo "$issue_info" | jq -r '.body // ""')
        issue_labels=$(echo "$issue_info" | jq -r '[.labels[].name] | join(", ")' 2>/dev/null || true)
    fi
    local slug=$(psm_slugify "$issue_title" 20)

    log_info "Issue: #${issue_number} - ${issue_title}"

    # Determine alias
    if [[ -z "$alias" ]]; then
        alias=$(echo "$repo" | tr '/' '-')
    fi

    # Determine local path
    if [[ -z "$local_path" || ! -d "$local_path" ]]; then
        local_path="${HOME}/Workspace/$(basename "${repo:-$alias}")"
        if [[ ! -d "$local_path" ]]; then
            log_info "Cloning repository..."
            local clone_url
            if [[ "$provider" == "jira" ]]; then
                clone_url=$(provider_call "jira" clone_url "$alias") || {
                    log_error "Failed to get clone URL for '$alias'. Configure 'repo' or 'clone_url' in projects.json"
                    return 1
                }
            else
                clone_url=$(provider_call "github" clone_url "$repo")
            fi
            git clone "$clone_url" "$local_path" || return 1
        fi
    fi

    # Create worktree
    log_info "Creating worktree and branch..."
    local worktree_result
    worktree_result=$(psm_create_issue_worktree "$local_path" "$alias" "$issue_number" "$slug" "$base")

    local worktree_status worktree_path branch_name
    IFS='|' read -r worktree_status worktree_path branch_name <<< "$worktree_result"

    if [[ "$worktree_status" == "exists" ]]; then
        log_warn "Worktree already exists at $worktree_path"
        return 0
    elif [[ "$worktree_status" == "error" ]]; then
        log_error "Failed to create worktree: $worktree_path"
        return 1
    fi

    log_success "Worktree created at $worktree_path"
    log_info "Branch: $branch_name"

    # Render issue fix context file into the worktree so Claude starts with full task context
    local fix_context_rel=".psm/fix.md"
    local fix_context_file="${worktree_path}/${fix_context_rel}"
    mkdir -p "$(dirname "$fix_context_file")"
    if ! psm_render_template "$SCRIPT_DIR/templates/issue-fix.md" \
            "ISSUE_NUMBER=${issue_number}" \
            "ISSUE_TITLE=${issue_title}" \
            "ISSUE_URL=${issue_url}" \
            "ISSUE_LABELS=${issue_labels}" \
            "ISSUE_BODY=${issue_body}" \
            "BRANCH_NAME=${branch_name}" \
            > "$fix_context_file"; then
        log_warn "Failed to render issue fix template; Claude will start without task context"
        fix_context_rel=""
    fi

    # Create tmux session
    local session_name="psm:${alias}:issue-${issue_number}"
    local session_id="${alias}:issue-${issue_number}"

    log_info "Creating tmux session..."
    psm_create_tmux_session "$session_name" "$worktree_path"

    if [[ "$no_claude" != "true" ]]; then
        psm_launch_claude "$session_name" "$fix_context_rel"
    fi

    # Create metadata
    local metadata
    metadata=$(jq -n \
      --argjson issue_number "$issue_number" \
      --arg issue_title "$issue_title" \
      --arg issue_url "$issue_url" \
      '{issue_number: $issue_number, issue_title: $issue_title, issue_url: $issue_url}')

    psm_add_session "$session_id" "fix" "$alias" "issue-${issue_number}" "$branch_name" "$base" "$session_name" "$worktree_path" "$local_path" "$metadata" "$provider" "$provider_ref"

    echo ""
    log_success "Session ready!"
    echo ""
    echo "  ID:       $session_id"
    echo "  Type:     fix"
    echo "  Issue:    #${issue_number} - ${issue_title}"
    echo "  Branch:   $branch_name"
    echo "  Worktree: $worktree_path"
    echo "  Tmux:     $session_name"
    echo ""
}

# Command: feature
cmd_feature() {
    local project="$1"
    local feature_name="$2"

    log_info "Creating feature session for: $feature_name"

    # Resolve project
    local project_info
    project_info=$(psm_get_project "$project")
    if [[ $? -ne 0 ]]; then
        log_error "Unknown project: $project"
        return 1
    fi

    IFS='|' read -r repo local_path base <<< "$project_info"

    if [[ ! -d "$local_path" ]]; then
        log_error "Local path not found: $local_path"
        return 1
    fi

    # Create worktree
    log_info "Creating worktree and branch..."
    local worktree_result
    worktree_result=$(psm_create_feature_worktree "$local_path" "$project" "$feature_name" "$base")

    local worktree_status worktree_path branch_name
    IFS='|' read -r worktree_status worktree_path branch_name <<< "$worktree_result"

    if [[ "$worktree_status" == "exists" ]]; then
        log_warn "Worktree already exists at $worktree_path"
        return 0
    elif [[ "$worktree_status" == "error" ]]; then
        log_error "Failed to create worktree"
        return 1
    fi

    log_success "Worktree created at $worktree_path"

    local safe_name=$(psm_sanitize "$feature_name")
    local session_name="psm:${project}:feat-${safe_name}"
    local session_id="${project}:feat-${safe_name}"

    psm_create_tmux_session "$session_name" "$worktree_path"
    local feature_prompt="Implement feature \"${feature_name}\" for project ${project}. Working branch: ${branch_name}. Build the feature, add tests, and open a PR when ready: gh pr create --title \"feat: ${feature_name}\""
    psm_launch_claude "$session_name" "$feature_prompt"

    psm_add_session "$session_id" "feature" "$project" "feat-${safe_name}" "$branch_name" "$base" "$session_name" "$worktree_path" "$local_path" "{}"

    echo ""
    log_success "Session ready!"
    echo ""
    echo "  ID:       $session_id"
    echo "  Type:     feature"
    echo "  Branch:   $branch_name"
    echo "  Worktree: $worktree_path"
    echo "  Tmux:     $session_name"
    echo ""
}

# Command: list
cmd_list() {
    local project="${1:-}"

    echo ""
    echo "Active PSM Sessions:"
    echo ""
    printf "%-25s | %-8s | %-10s | %s\n" "ID" "Type" "State" "Worktree"
    printf "%-25s-+-%-8s-+-%-10s-+-%s\n" "-------------------------" "--------" "----------" "----------------------------------------"

    psm_list_sessions "$project" | while IFS='|' read -r id type state worktree; do
        # Check if tmux session exists
        local tmux_state="detached"
        if psm_tmux_session_exists "psm:${id}"; then
            tmux_state="$state"
        else
            tmux_state="no-tmux"
        fi

        printf "%-25s | %-8s | %-10s | %s\n" "$id" "$type" "$tmux_state" "$worktree"
    done

    echo ""
}

# Command: attach
cmd_attach() {
    local session_id="$1"
    local session_name="psm:${session_id}"

    if ! psm_tmux_session_exists "$session_name"; then
        log_error "Session not found: $session_name"
        log_info "Use 'psm list' to see available sessions"
        return 1
    fi

    echo "Attaching to $session_name..."
    echo "Run: tmux attach -t $session_name"
}

# Command: kill
cmd_kill() {
    local session_id="$1"

    log_info "Killing session: $session_id"

    # Get session info
    local session_json
    session_json=$(psm_get_session "$session_id")
    if [[ -z "$session_json" ]]; then
        log_error "Session not found in registry: $session_id"
        return 1
    fi

    local tmux_name=$(echo "$session_json" | jq -r '.tmux')
    local worktree_path=$(echo "$session_json" | jq -r '.worktree')
    local source_repo=$(echo "$session_json" | jq -r '.source_repo')

    # Kill tmux
    psm_kill_tmux_session "$tmux_name"
    log_info "Killed tmux session: $tmux_name"

    # Remove worktree
    psm_remove_worktree "$source_repo" "$worktree_path"
    log_info "Removed worktree: $worktree_path"

    # Remove from registry
    psm_remove_session "$session_id"
    log_info "Removed from registry"

    log_success "Session killed: $session_id"
}

# Command: cleanup
cmd_cleanup() {
    local force="${1:-false}"

    log_info "Starting cleanup..."

    local cleaned=0

    # Check PR sessions (GitHub only)
    while IFS='|' read -r id pr_number project; do
        if [[ -z "$id" ]]; then continue; fi

        local session_json=$(psm_get_session "$id")
        local provider=$(echo "$session_json" | jq -r '.provider // "github"')

        # Only GitHub has PRs
        if [[ "$provider" != "github" ]]; then continue; fi

        local repo=$(psm_get_project "$project" | cut -d'|' -f1)

        if [[ -n "$repo" && -n "$pr_number" ]]; then
            if provider_github_available && provider_call "github" pr_merged "$pr_number" "$repo"; then
                log_info "PR #${pr_number} is merged - cleaning up $id"
                cmd_kill "$id"
                ((cleaned++))
            fi
        fi
    done < <(psm_get_review_sessions)

    # Check issue sessions (GitHub and Jira)
    while IFS='|' read -r id issue_number project; do
        if [[ -z "$id" ]]; then continue; fi

        local session_json=$(psm_get_session "$id")
        local provider=$(echo "$session_json" | jq -r '.provider // "github"')
        local provider_ref=$(echo "$session_json" | jq -r '.provider_ref // empty')

        if [[ "$provider" == "jira" ]]; then
            # Jira cleanup
            if provider_jira_available && [[ -n "$provider_ref" ]]; then
                if provider_call "jira" issue_closed "$provider_ref"; then
                    log_info "Jira issue ${provider_ref} is done - cleaning up $id"
                    cmd_kill "$id"
                    ((cleaned++))
                fi
            fi
        else
            # GitHub cleanup
            local repo=$(psm_get_project "$project" | cut -d'|' -f1)
            if provider_github_available && [[ -n "$repo" && -n "$issue_number" ]]; then
                if provider_call "github" issue_closed "$issue_number" "$repo"; then
                    log_info "Issue #${issue_number} is closed - cleaning up $id"
                    cmd_kill "$id"
                    ((cleaned++))
                fi
            fi
        fi
    done < <(psm_get_fix_sessions)

    if [[ $cleaned -eq 0 ]]; then
        log_success "Cleanup complete - no sessions to clean"
    else
        log_success "Cleanup complete - removed $cleaned session(s)"
    fi
}

# Command: status
cmd_status() {
    # Try to detect current session
    local current_session=$(psm_current_tmux_session)

    if [[ -n "$current_session" && "$current_session" == psm:* ]]; then
        local session_id="${current_session#psm:}"
        local session_json=$(psm_get_session "$session_id")

        if [[ -n "$session_json" ]]; then
            echo ""
            echo "Current Session: $session_id"
            echo ""
            echo "  Type:       $(echo "$session_json" | jq -r '.type')"
            echo "  Branch:     $(echo "$session_json" | jq -r '.branch')"
            echo "  Base:       $(echo "$session_json" | jq -r '.base')"
            echo "  Worktree:   $(echo "$session_json" | jq -r '.worktree')"
            echo "  Created:    $(echo "$session_json" | jq -r '.created_at')"
            echo ""
            return 0
        fi
    fi

    # Check if we're in a worktree
    local cwd=$(pwd)
    local worktree_root=$(psm_get_worktree_root)

    if [[ "$cwd" == "$worktree_root"* ]]; then
        local meta_file="${cwd}/.psm-session.json"
        if [[ -f "$meta_file" ]]; then
            cat "$meta_file" | jq .
            return 0
        fi
    fi

    log_info "Not in a PSM session"
    log_info "Use 'psm list' to see available sessions"
}

# Main entry point
main() {
    if [[ $# -eq 0 ]]; then
        usage
        exit 0
    fi

    # Check dependencies first
    check_dependencies

    # Initialize PSM
    psm_init

    local cmd="$1"
    shift

    case "$cmd" in
        review|r|pr)
            if [[ $# -lt 1 ]]; then
                log_error "Usage: psm review <ref>"
                exit 1
            fi
            cmd_review "$@"
            ;;
        fix|issue|i)
            if [[ $# -lt 1 ]]; then
                log_error "Usage: psm fix <ref>"
                exit 1
            fi
            cmd_fix "$@"
            ;;
        feature|feat|f)
            if [[ $# -lt 2 ]]; then
                log_error "Usage: psm feature <project> <name>"
                exit 1
            fi
            cmd_feature "$@"
            ;;
        list|ls|l)
            cmd_list "$@"
            ;;
        attach|a)
            if [[ $# -lt 1 ]]; then
                log_error "Usage: psm attach <session>"
                exit 1
            fi
            cmd_attach "$@"
            ;;
        kill|k|rm)
            if [[ $# -lt 1 ]]; then
                log_error "Usage: psm kill <session>"
                exit 1
            fi
            cmd_kill "$@"
            ;;
        cleanup|gc|clean)
            cmd_cleanup "$@"
            ;;
        status|st)
            cmd_status
            ;;
        help|-h|--help)
            usage
            ;;
        *)
            log_error "Unknown command: $cmd"
            usage
            exit 1
            ;;
    esac
}

# Run if executed directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi