 {
  "type": "object",
  "properties": {
    "reviews": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "fileName": {
            "type": "string",
            "description": "The file path being reviewed"
          },
          "lineNumber": {
            "type": "integer",
            "description": "The line number where the issue occurs"
          },
          "comment": {
            "type": "string",
            "description": "The review comment with emoji, severity, category, explanation and an optional suggested fix"
          }
        },
        "required": ["fileName", "lineNumber", "comment"],
        "additionalProperties": false
      }
    }
  },
  "required": ["reviews"],
  "additionalProperties": false
 }
 function Get-CodeChanges {
    param (
        [string]$TargetBranch,
        [string]$SourceBranch
    )

    $renamedSourceBranch = $SourceBranch -replace 'refs/heads/', 'origin/'
    $renamedTargetBranch = $TargetBranch -replace 'refs/heads/', 'origin/'

    # Get changed code files only
    $changedFiles = git diff --name-only --diff-filter=AM "$renamedTargetBranch...$renamedSourceBranch"

    # Add legend for diff markers
    $llmOutput = @"
 # Code Review - Changes from $renamedSourceBranch to $renamedTargetBranch

 ## Legend:
 - `+` = Added lines (new code)
 - `-` = Removed lines (deleted code)
 - `  ` = Unchanged lines (context)

 ---

 "@

    foreach ($file in $changedFiles) {
        Write-Host "Processing: $file"

        # Ensure file path starts with / for full path from repository root
        $fullPath = if ($file.StartsWith('/')) { $file } else { "/$file" }

        # Get the unified diff with more context
        $diffLines = git diff "$renamedTargetBranch...$renamedSourceBranch" --unified=5 -- $file

        $llmOutput += "## File: $fullPath`n`n"

        # Parse the diff output line by line
        $inHunk = $false
        $oldLineNum = 0
        $newLineNum = 0
        $hunkContent = @()
        $addedLines = 0
        $removedLines = 0

        foreach ($line in $diffLines) {
            # Check for hunk header
            if ($line -match '^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@') {
                # If we were processing a previous hunk, output it
                if ($hunkContent.Count -gt 0) {
                    $llmOutput += "### Changes: +$addedLines lines, -$removedLines lines`n"
                    $llmOutput += ($hunkContent -join "`n")
                    $llmOutput += "`n`n"
                }

                # Reset for new hunk
                $hunkContent = @()
                $addedLines = 0
                $removedLines = 0
                $inHunk = $true
                $oldLineNum = [int]$matches[1]
                $newLineNum = [int]$matches[3]
                continue
            }

            # Skip file headers
            if ($line -match '^(diff --git|index|\+\+\+|---|\\ No newline)' -or $line.StartsWith('Binary file')) {
                continue
            }

            # Process hunk content
            if ($inHunk) {
                if ($line.StartsWith('+')) {
                    # Added line
                    $hunkContent += "{0,4}+ {1}" -f $newLineNum, $line.Substring(1)
                    $newLineNum++
                    $addedLines++
                }
                elseif ($line.StartsWith('-')) {
                    # Removed line
                    $hunkContent += "{0,4}- {1}" -f $oldLineNum, $line.Substring(1)
                    $oldLineNum++
                    $removedLines++
                }
                elseif ($line.StartsWith(' ')) {
                    # Context line (unchanged)
                    $hunkContent += "{0,4}  {1}" -f $newLineNum, $line.Substring(1)
                    $oldLineNum++
                    $newLineNum++
                }
                else {
                    # End of hunk
                    $inHunk = $false
                }
            }
        }

        # Output the last hunk if any
        if ($hunkContent.Count -gt 0) {
            $llmOutput += "### Changes: +$addedLines lines, -$removedLines lines`n"
            $llmOutput += ($hunkContent -join "`n")
            $llmOutput += "`n"
        }
        $llmOutput += "`n---`n"
    }

    return $llmOutput
 }
 function Invoke-LLMCodeReview {
    param (
        [parameter(Mandatory)]
        [string]
        $SourceBranch,

        [parameter(Mandatory)]
        [string]
        $TargetBranch,

        [Parameter(Mandatory)]
        [string]
        $PathToReviewFile,

        [parameter(Mandatory)]
        [string]
        $ModelName,

        [parameter(Mandatory)]
        [string]
        $ModelDeploymentUrl,

        [parameter(Mandatory)]
        [string]
        $Key
    )

    $schema = @{
        type                 = "object"
        properties           = @{
            reviews = @{
                type  = "array"
                items = @{
                    type                 = "object"
                    properties           = @{
                        fileName   = @{
                            type        = "string"
                            description = "The file path being reviewed"
                        }
                        lineNumber = @{
                            type        = "integer"
                            description = "The line number where the issue occurs"
                        }
                        comment    = @{
                            type        = "string"
                            description = "The review comment with emoji, severity, category, explanation and an optional suggested fix"
                        }
                    }
                    required             = @("fileName", "lineNumber", "comment")
                    additionalProperties = $false
                }
            }
        }
        required             = @("reviews")
        additionalProperties = $false
    }

    [string] $changes = Get-CodeChanges -SourceBranch $SourceBranch -TargetBranch $TargetBranch | Out-String
    Write-Host "Code changes to review:`n$changes"

    # Completion text
    $messages = @()
    $messages += @{
        role    = 'system'
        content = @(
            @{
                type = "text"
                text = Get-Content -Path $PathToReviewFile -Raw
            }
        )
    }
    $messages += @{
        role    = 'user'
        content = @(
            @{
                type = "text"
                text = $changes
            }
        )
    }

    # Header for authentication
    $headers = [ordered]@{
        "Authorization" = "Bearer $($Key)"
    }

    # Adjust these values to fine-tune completions
    $body = [ordered]@{
        model           = $ModelName
        messages        = $messages
        response_format = @{
            type        = "json_schema"
            json_schema = @{
                name   = "CodeReviewResponse" # A required property
                strict = $true # Recommended for structured outputs
                schema = $schema # The JSON schema that defines the expected response structure
            }
        }
    } | ConvertTo-Json -Depth 99

    $response = Invoke-RestMethod `
        -Uri $ModelDeploymentUrl `
        -Headers $headers `
        -Body $body `
        -Method Post `
        -ContentType 'application/json'


    if ($ModelName -eq "model-router") {
        Write-Host "Response from $ModelName using $($response.model):"
        Write-Host ($response.choices.message.content | ConvertTo-Json)
    } else {
        Write-Host "Response from $($ModelName):"
        Write-Host ($response.choices.message.content | ConvertTo-Json)
    }

    return $response.choices.message.content
 }
 function Set-PullRequestComments {
    param (
        [parameter(Mandatory)]
        [string]
        $Organization,

        [parameter(Mandatory)]
        [int]
        $PullRequestId,

        [Parameter(Mandatory)]
        [string]
        $RepositoryName,

        [parameter(Mandatory)]
        [string]
        $Project,

        [parameter(Mandatory)]
        [string]
        $Reviews,

        [parameter()]
        [switch]
        $AutoApprove
    )

    $token = (New-Object System.Management.Automation.PSCredential("token", (Get-AzAccessToken -ResourceUrl "499b84ac-1321-427f-aa17-267ca6975798" -AsSecureString).token)).GetNetworkCredential().Password
    $headers = @{
        Authorization  = "Bearer $token"
        "Content-Type" = "application/json"
    }

    # Get current authenticated user from Azure DevOps
    $connectionData = Invoke-RestMethod -Uri "https://dev.azure.com/$Organization/_apis/connectionData&quot; -Headers $headers -Method Get
    $currentUserName = $connectionData.authenticatedUser.providerDisplayName
    Write-Host "Checking for existing comments from: $currentUserName"

    # Get existing threads
    $getThreadsUrl = "https://dev.azure.com/$Organization/$Project/_apis/git/repositories/$RepositoryName/pullRequests/$PullRequestId/threads?api-version=7.1&quot;

    try {
        $existingThreads = Invoke-RestMethod -Uri $getThreadsUrl -Headers $headers -Method Get
    }
    catch {
        Write-Warning "Failed to retrieve existing threads, continuing without duplicate check..."
        $existingThreads = $null
    }

    # Build a lookup hashtable of existing comments by file:line
    $existingComments = @{}
    if ($existingThreads) {
        foreach ($thread in $existingThreads.value) {
            # Skip deleted threads or threads without context
            if ($thread.isDeleted -or -not $thread.threadContext -or -not $thread.threadContext.filePath) {
                continue
            }

            if ($thread.status -notin @("active", "pending", "fixed", "wontFix", "closed")) {
                continue
            }

            # Check if any comment is from the current user (not deleted)
            $hasUserComment = $thread.comments | Where-Object {
                $_.author.displayName -eq $currentUserName 
            } | Select-Object -First 1

            if ($hasUserComment) {
                # Normalize file path (lowercase, ensure leading /)
                $normalizedPath = $thread.threadContext.filePath.ToLower()
                if (-not $normalizedPath.StartsWith('/')) {
                    $normalizedPath = "/$normalizedPath"
                }
                $key = "$normalizedPath|$($thread.threadContext.rightFileStart.line)"
                $existingComments[$key] = $true
            }
        }
    }

    # Parse and validate reviews
    $reviewsObject = $Reviews | ConvertFrom-Json
    if ($null -eq $reviewsObject.reviews -or $reviewsObject.reviews.Count -eq 0) {
        Write-Host "No reviews to post."
        
        if ($AutoApprove) {
            Write-Host "AutoApprove enabled: Approving pull request..." -ForegroundColor Cyan
            $reviewerId = $connectionData.authenticatedUser.id
            $approveUrl = "https://dev.azure.com/$Organization/$Project/_apis/git/repositories/$RepositoryName/pullRequests/$PullRequestId/reviewers/$($reviewerId)?api-version=7.1"
            
            $approveBody = @{
                vote = 10
            }
            
            try {
                $null = Invoke-RestMethod -Uri $approveUrl -Headers $headers -Method Put -Body ($approveBody | ConvertTo-Json -Depth 10)
                Write-Host "Pull request approved successfully." -ForegroundColor Green
            }
            catch {
                Write-Warning "Failed to approve pull request: $_"
            }
        }
        
        return
    }

    # Filter out duplicate reviews
    $newReviews = $reviewsObject.reviews | Where-Object {
        # Normalize file path
        $normalizedPath = $_.fileName.ToLower()
        if (-not $normalizedPath.StartsWith('/')) {
            $normalizedPath = "/$normalizedPath"
        }
        $key = "$normalizedPath|$($_.lineNumber)"

        # Keep only reviews that don't exist yet
        -not $existingComments.ContainsKey($key)
    }

    if ($newReviews.Count -eq 0) {
        Write-Host "All comments already exist. No new comments to post." -ForegroundColor Yellow
        return
    }

    $skipped = $reviewsObject.reviews.Count - $newReviews.Count
    if ($skipped -gt 0) {
        Write-Host "Skipping $skipped duplicate comment(s)" -ForegroundColor Yellow
    }

    # Post new reviews
    $createThreadUrl = "https://dev.azure.com/$Organization/$Project/_apis/git/repositories/$RepositoryName/pullRequests/$PullRequestId/threads?api-version=7.1&quot;

    foreach ($review in $newReviews) {
        # Determine line range for suggestions
        $startLine = $review.lineNumber
        $endLine = $review.lineNumber
        $endOffset = 1000

        $threadBody = @{
            comments      = @(
                @{
                    parentCommentId = 0
                    content         = $review.comment
                    commentType     = 1
                }
            )
            status        = 1
            threadContext = @{
                filePath       = $review.fileName
                rightFileStart = @{ line = $startLine; offset = 1 }
                rightFileEnd   = @{ line = $endLine; offset = $endOffset }
            }
        }

        try {
            $response = Invoke-RestMethod -Uri $createThreadUrl -Headers $headers -Method Post -Body ($threadBody | ConvertTo-Json -Depth 10)
            Write-Host "Comment posted on '$($review.fileName)' line $($review.lineNumber) (Thread ID: $($response.id))" -ForegroundColor Green
        }
        catch {
            Write-Warning "Failed to post comment on '$($review.fileName)' line $($review.lineNumber): $_"
        }
    }
 }
 trigger: none

 pool:
  vmImage: ubuntu-latest

 variables:
 - group: vg-foundry

 steps:
 - checkout: self
  persistCredentials: true
  fetchDepth: 0

 - task: AzurePowerShell@5
  displayName: 'Automated Code Reviewer'
  inputs:
    azureSubscription: sc-devops-code-reviewer
    ScriptType: 'InlineScript'
    azurePowerShellVersion: LatestVersion
    pwsh: true
    Inline: |
      . ./Get-CodeChanges.ps1
      . ./Invoke-LLMCodeReview.ps1
      . ./Set-PullRequestComments.ps1

      [string]$changes = Invoke-LLMCodeReview `
        -SourceBranch $(System.PullRequest.SourceBranch) `
        -TargetBranch $(System.PullRequest.TargetBranch) `
        -PathToReviewFile './Generic.reviewpromtpfile.md' `
        -ModelName 'gpt-5.1-chat' `
        -ModelDeploymentUrl 'https://<Microsoft Foundry Instance>.cognitiveservices.azure.com/openai/deployments/gpt-5.1-chat/chat/completions?api-version=2025-01-01-preview' `
        -Key $(foundry-key)

      Set-PullRequestComments `
        -Organization ("$(System.CollectionUri)" -split "/" | Select-Object -index 3) `
        -PullRequestId $(System.PullRequest.PullRequestId) `
        -Project $(System.TeamProject) `
        -RepositoryName $(Build.Repository.Name) `
        -Reviews $changes