# This workflow assists in evaluating the severity of incoming issues to help
# with triaging tickets. It uses AI analysis to classify issues into severity levels
# (s0-s4) when the 'triage-check' label is applied.

name: Classify Issue Severity

on:
  issues:
    types: [labeled]
  workflow_dispatch:
    inputs:
      issue_url:
        description: "Issue URL to classify"
        required: true
        type: string
      template_preset:
        description: "Template preset to use"
        required: false
        default: ""
        type: string

permissions:
  contents: read

jobs:
  classify-severity:
    name: AI Severity Classification
    runs-on: ubuntu-latest
    if: |
      (github.event.label.name == 'triage-check' || github.event_name == 'workflow_dispatch')
    timeout-minutes: 30
    env:
      CODER_URL: ${{ secrets.DOC_CHECK_CODER_URL }}
      CODER_SESSION_TOKEN: ${{ secrets.DOC_CHECK_CODER_SESSION_TOKEN }}
    permissions:
      contents: read
      issues: write

    steps:
      - name: Determine Issue Context
        id: determine-context
        env:
          GITHUB_ACTOR: ${{ github.actor }}
          GITHUB_EVENT_NAME: ${{ github.event_name }}
          GITHUB_EVENT_ISSUE_HTML_URL: ${{ github.event.issue.html_url }}
          GITHUB_EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
          GITHUB_EVENT_SENDER_ID: ${{ github.event.sender.id }}
          GITHUB_EVENT_SENDER_LOGIN: ${{ github.event.sender.login }}
          INPUTS_ISSUE_URL: ${{ inputs.issue_url }}
          INPUTS_TEMPLATE_PRESET: ${{ inputs.template_preset || '' }}
          GH_TOKEN: ${{ github.token }}
        run: |
          echo "Using template preset: ${INPUTS_TEMPLATE_PRESET}"
          echo "template_preset=${INPUTS_TEMPLATE_PRESET}" >> "${GITHUB_OUTPUT}"

          # For workflow_dispatch, use the provided issue URL
          if [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" ]]; then
            if ! GITHUB_USER_ID=$(gh api "users/${GITHUB_ACTOR}" --jq '.id'); then
              echo "::error::Failed to get GitHub user ID for actor ${GITHUB_ACTOR}"
              exit 1
            fi
            echo "Using workflow_dispatch actor: ${GITHUB_ACTOR} (ID: ${GITHUB_USER_ID})"
            echo "github_user_id=${GITHUB_USER_ID}" >> "${GITHUB_OUTPUT}"
            echo "github_username=${GITHUB_ACTOR}" >> "${GITHUB_OUTPUT}"

            echo "Using issue URL: ${INPUTS_ISSUE_URL}"
            echo "issue_url=${INPUTS_ISSUE_URL}" >> "${GITHUB_OUTPUT}"

            # Extract issue number from URL for later use
            ISSUE_NUMBER=$(echo "${INPUTS_ISSUE_URL}" | grep -oP '(?<=issues/)\d+')
            echo "issue_number=${ISSUE_NUMBER}" >> "${GITHUB_OUTPUT}"

          elif [[ "${GITHUB_EVENT_NAME}" == "issues" ]]; then
            GITHUB_USER_ID=${GITHUB_EVENT_SENDER_ID}
            echo "Using label adder: ${GITHUB_EVENT_SENDER_LOGIN} (ID: ${GITHUB_USER_ID})"
            echo "github_user_id=${GITHUB_USER_ID}" >> "${GITHUB_OUTPUT}"
            echo "github_username=${GITHUB_EVENT_SENDER_LOGIN}" >> "${GITHUB_OUTPUT}"

            echo "Using issue URL: ${GITHUB_EVENT_ISSUE_HTML_URL}"
            echo "issue_url=${GITHUB_EVENT_ISSUE_HTML_URL}" >> "${GITHUB_OUTPUT}"
            echo "issue_number=${GITHUB_EVENT_ISSUE_NUMBER}" >> "${GITHUB_OUTPUT}"

          else
            echo "::error::Unsupported event type: ${GITHUB_EVENT_NAME}"
            exit 1
          fi

      - name: Build Classification Prompt
        id: build-prompt
        env:
          ISSUE_URL: ${{ steps.determine-context.outputs.issue_url }}
          ISSUE_NUMBER: ${{ steps.determine-context.outputs.issue_number }}
          GH_TOKEN: ${{ github.token }}
        run: |
          echo "Analyzing issue #${ISSUE_NUMBER}"

          # Build task prompt - using unquoted heredoc so variables expand
          TASK_PROMPT=$(cat <<EOF
          You are an expert software engineer triaging customer-reported issues for Coder, a cloud development environment platform.

          Your task is to carefully analyze issue #${ISSUE_NUMBER} and classify it into one of the following severity levels. **This requires deep reasoning and thoughtful analysis** - not just keyword matching.

          Issue URL: ${ISSUE_URL}

          WORKFLOW:
            1. Use GitHub MCP tools to fetch the full issue details
               Get the title, description, labels, and any comments that provide context

            2. Read and understand the issue
               What is the user reporting?
               What are the symptoms?
               What is the expected vs actual behavior?

            3. Analyze using the framework below
               Think deeply about each of the 5 analysis points
               Don't just match keywords - reason about the actual impact

            4. Classify the severity OR decline if insufficient information

            5. Comment on the issue with your analysis

          ## Severity Level Definitions

          - **s0**: Entire product and/or major feature (Tasks, Bridge, Boundaries, etc.) is broken in a way that makes it unusable for majority to all customers

          - **s1**: Core feature is broken without a workaround for limited number of customers

          - **s2**: Broken use cases or features with a workaround

          - **s3**: Issues that impair usability, cause incorrect behavior in non-critical areas, or degrade the experience, but do not block core workflows

          - **s4**: Bugs that confuse or annoy or are purely cosmetic, e.g. we don't plan on addressing them

          ## Analysis Framework

          Customers often overstate the severity of issues. You need to read between the lines and assess the **actual impact** by reasoning through:

          1. **What is actually broken?**
             - Distinguish between what the customer *says* is broken vs. what is *actually* broken
             - Is this a complete failure or a partial degradation?
             - Does the error message or symptom indicate a critical vs. minor issue?

          2. **How many users are affected?**
             - Is this affecting all customers, many customers, or a specific edge case?
             - Does the issue description suggest widespread impact or isolated incident?
             - Are there environmental factors that limit the scope?

          3. **Are there workarounds?**
             - Can users accomplish their goal through an alternative path?
             - Is there a manual process or configuration change that resolves it?
             - Even if not mentioned, do you suspect a workaround exists?

          4. **Does it block critical workflows?**
             - Can users still perform their core job functions?
             - Is this interrupting active development work or just an inconvenience?
             - What is the business impact if this remains unresolved?

          5. **What is the realistic urgency?**
             - Does this need immediate attention or can it wait?
             - Is this a regression or long-standing issue?
             - What's the actual business risk?

          ## Insufficient Information Fail-Safe

          **It is completely acceptable to not classify an issue if you lack sufficient information.**

          If the issue description is too vague, missing critical details, or doesn't provide enough context to make a confident assessment, DO NOT force a classification.

          Common scenarios where you should decline to classify:
          - Issue has no description or minimal details
          - Unclear what feature/component is affected
          - No reproduction steps or error messages provided
          - Ambiguous whether it's a bug, feature request, or question
          - Missing information about user impact or frequency

          ## Comment Format

          Use ONE of these two formats when commenting on the issue:

          ### Format 1: Confident Classification

          ## 🤖 Automated Severity Classification

          **Recommended Severity:** \`S0\` | \`S1\` | \`S2\` | \`S3\` | \`S4\`

          **Analysis:**
          [2-3 sentences explaining your reasoning - focus on the actual impact, not just symptoms. Explain why you chose this severity level over others.]

          ---
          *This classification was performed by AI analysis. Please review and adjust if needed.*

          ### Format 2: Insufficient Information

          ## 🤖 Automated Severity Classification

          **Status:** Unable to classify - insufficient information

          **Reasoning:**
          [2-3 sentences explaining what critical information is missing and why it's needed to determine severity.]

          **Suggested next steps:**
          - [Specific information point 1]
          - [Specific information point 2]
          - [Specific information point 3]

          ---
          *This classification was performed by AI analysis. Please provide the requested information for proper severity assessment.*

          EOF
          )

          # Output the prompt
          {
            echo "task_prompt<<EOFOUTPUT"
            echo "${TASK_PROMPT}"
            echo "EOFOUTPUT"
          } >> "${GITHUB_OUTPUT}"

      - name: Checkout create-task-action
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          fetch-depth: 1
          path: ./.github/actions/create-task-action
          persist-credentials: false
          ref: main
          repository: coder/create-task-action

      - name: Create Coder Task for Severity Classification
        id: create_task
        uses: ./.github/actions/create-task-action
        with:
          coder-url: ${{ secrets.DOC_CHECK_CODER_URL }}
          coder-token: ${{ secrets.DOC_CHECK_CODER_SESSION_TOKEN }}
          coder-organization: "default"
          coder-template-name: coder
          coder-template-preset: ${{ steps.determine-context.outputs.template_preset }}
          coder-task-name-prefix: severity-classification
          coder-task-prompt: ${{ steps.build-prompt.outputs.task_prompt }}
          github-user-id: ${{ steps.determine-context.outputs.github_user_id }}
          github-token: ${{ github.token }}
          github-issue-url: ${{ steps.determine-context.outputs.issue_url }}
          comment-on-issue: true

      - name: Write outputs
        env:
          TASK_CREATED: ${{ steps.create_task.outputs.task-created }}
          TASK_NAME: ${{ steps.create_task.outputs.task-name }}
          TASK_URL: ${{ steps.create_task.outputs.task-url }}
          ISSUE_URL: ${{ steps.determine-context.outputs.issue_url }}
        run: |
          {
            echo "## Severity Classification Task"
            echo ""
            echo "**Issue:** ${ISSUE_URL}"
            echo "**Task created:** ${TASK_CREATED}"
            echo "**Task name:** ${TASK_NAME}"
            echo "**Task URL:** ${TASK_URL}"
            echo ""
            echo "The Coder task is analyzing the issue and will comment with severity classification."
          } >> "${GITHUB_STEP_SUMMARY}"