@mcp-consultant-tools/azure-devops 26.0.0-beta.1 → 27.0.0-beta.10

package/build/AzureDevOpsService.js

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { marked } from 'marked';
+import { getAllLargeTextFields } from './sync/html-detection.js';
 export class AzureDevOpsService {
     config;
     baseUrl;
@@ -13,20 +14,7 @@ export class AzureDevOpsService {
             enableWorkItemWrite: config.enableWorkItemWrite ?? false,
             enableWorkItemDelete: config.enableWorkItemDelete ?? false,
             enableWikiWrite: config.enableWikiWrite ?? false,
-            // Tier 1: Read-only (master switch)
-            showDevOpsAdminReadonly: config.showDevOpsAdminReadonly ?? false,
-            // Tier 2: Upsert (create + update)
-            enablePipelineUpsert: config.enablePipelineUpsert ?? false,
-            enableServiceConnUpsert: config.enableServiceConnUpsert ?? false,
-            enableVariableGroupUpsert: config.enableVariableGroupUpsert ?? false,
-            enableAgentPoolUpsert: config.enableAgentPoolUpsert ?? false,
-            enableEnvironmentUpsert: config.enableEnvironmentUpsert ?? false,
-            // Tier 3: Delete/Disable (destructive operations)
-            enablePipelineDelete: config.enablePipelineDelete ?? false,
-            enableServiceConnDelete: config.enableServiceConnDelete ?? false,
-            enableVariableGroupDelete: config.enableVariableGroupDelete ?? false,
-            enableAgentPoolDisable: config.enableAgentPoolDisable ?? false,
-            enableEnvironmentDelete: config.enableEnvironmentDelete ?? false,
+            enablePullRequestWrite: config.enablePullRequestWrite ?? false,
         };
         this.baseUrl = `https://dev.azure.com/${this.config.organization}`;
         this.searchUrl = `https://almsearch.dev.azure.com/${this.config.organization}`;
@@ -527,8 +515,8 @@ export class AzureDevOpsService {
         this.validateProject(project);
         // Comments API requires -preview suffix (not GA in 7.1)
         const response = await this.makeRequest(`${project}/_apis/wit/workItems/${workItemId}/comments?api-version=7.1-preview`);
-        // Handle case where response.value may be undefined or empty
-        const comments = response.value || [];
+        // v7.1 Comments API returns array in response.comments, not response.value
+        const comments = response.comments || response.value || [];
         return {
             workItemId,
             project,
@@ -595,6 +583,25 @@ export class AzureDevOpsService {
             project
         };
     }
+    /**
+     * Set work item field(s) to markdown format.
+     * This is IRREVERSIBLE - once set to markdown, cannot revert to HTML.
+     *
+     * @param project - Project name
+     * @param workItemId - Work item ID
+     * @param fields - Array of field names to set to markdown format (e.g., ['System.Description'])
+     */
+    async setFieldsToMarkdownFormat(project, workItemId, fields) {
+        if (!this.config.enableWorkItemWrite) {
+            throw new Error('Work item write operations are disabled. Set AZUREDEVOPS_ENABLE_WORK_ITEM_WRITE=true to enable.');
+        }
+        const patchOperations = fields.map(field => ({
+            op: 'add',
+            path: `/multilineFieldsFormat/${field}`,
+            value: 'Markdown'
+        }));
+        await this.updateWorkItem(project, workItemId, patchOperations);
+    }
     /**
      * Create a new work item
      * @param project The project name
@@ -619,6 +626,19 @@ export class AzureDevOpsService {
                 value: fields[field]
             });
         });
+        // Auto-set markdown format for large text fields that are being set
+        // This ensures all new work items use markdown format (irreversible)
+        // Uses getAllLargeTextFields() to include custom fields like Custom.Howtotest
+        const allLargeTextFields = getAllLargeTextFields();
+        for (const field of allLargeTextFields) {
+            if (fields[field] !== undefined) {
+                patchOperations.push({
+                    op: 'add',
+                    path: `/multilineFieldsFormat/${field}`,
+                    value: 'Markdown'
+                });
+            }
+        }
         // Handle parentId parameter (simplified parent relationship)
         if (parentId !== undefined) {
             const parentUrl = `${this.baseUrl}/${encodeURIComponent(project)}/_apis/wit/workItems/${parentId}`;
@@ -739,167 +759,17 @@ export class AzureDevOpsService {
         };
     }
     // ═══════════════════════════════════════════════════════════════════════════════
-    // PIPELINE/BUILD OPERATIONS (DevOps Admin Tools)
+    // BUILD TROUBLESHOOTING OPERATIONS (Read-only)
+    // NOTE: These methods are duplicated in azure-devops-admin package.
+    // If you update these, also update packages/azure-devops-admin/src/AzureDevOpsAdminService.ts
     // ═══════════════════════════════════════════════════════════════════════════════
     /**
-     * List all pipeline definitions in a project
-     * @param project The project name
-     * @returns List of pipeline definitions
-     */
-    async listPipelineDefinitions(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            pipelines: response.value.map((def) => ({
-                id: def.id,
-                name: def.name,
-                path: def.path,
-                revision: def.revision,
-                type: def.type,
-                queueStatus: def.queueStatus,
-                createdDate: def.createdDate,
-                authoredBy: def.authoredBy?.displayName,
-                repository: def.repository ? {
-                    id: def.repository.id,
-                    name: def.repository.name,
-                    type: def.repository.type
-                } : null,
-                process: def.process ? {
-                    type: def.process.type,
-                    yamlFilename: def.process.yamlFilename
-                } : null,
-                url: def._links?.web?.href
-            }))
-        };
-    }
-    /**
-     * Get a specific pipeline definition with full details
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @returns Full pipeline definition
-     */
-    async getPipelineDefinition(project, definitionId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            path: response.path,
-            revision: response.revision,
-            type: response.type,
-            queueStatus: response.queueStatus,
-            quality: response.quality,
-            createdDate: response.createdDate,
-            authoredBy: response.authoredBy?.displayName,
-            project: response.project?.name,
-            repository: response.repository ? {
-                id: response.repository.id,
-                name: response.repository.name,
-                type: response.repository.type,
-                defaultBranch: response.repository.defaultBranch,
-                url: response.repository.url
-            } : null,
-            process: response.process ? {
-                type: response.process.type,
-                yamlFilename: response.process.yamlFilename
-            } : null,
-            triggers: response.triggers || [],
-            variables: response.variables ? Object.keys(response.variables).reduce((acc, key) => {
-                const variable = response.variables[key];
-                acc[key] = {
-                    value: variable.isSecret ? '***SECRET***' : variable.value,
-                    isSecret: variable.isSecret || false,
-                    allowOverride: variable.allowOverride || false
-                };
-                return acc;
-            }, {}) : {},
-            queue: response.queue ? {
-                id: response.queue.id,
-                name: response.queue.name,
-                pool: response.queue.pool?.name
-            } : null,
-            url: response._links?.web?.href
-        };
-    }
-    /**
-     * Get the YAML content for a pipeline definition
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @returns YAML content or location info for external repos
-     */
-    async getPipelineYaml(project, definitionId) {
-        this.validateProject(project);
-        // First get the pipeline definition to check repo type
-        const definition = await this.getPipelineDefinition(project, definitionId);
-        // If external repo (GitHub, Bitbucket, etc.), return helpful info instead of failing
-        if (definition.repository?.type && definition.repository.type !== 'TfsGit') {
-            return {
-                definitionId,
-                project,
-                pipelineName: definition.name,
-                yamlLocation: 'external',
-                repositoryType: definition.repository.type,
-                repositoryName: definition.repository.name,
-                repositoryUrl: definition.repository.url,
-                defaultBranch: definition.repository.defaultBranch,
-                yamlFilename: definition.process?.yamlFilename,
-                message: `YAML is stored in external ${definition.repository.type} repository. ` +
-                    `To view the YAML content, access the file "${definition.process?.yamlFilename}" ` +
-                    `at ${definition.repository.url}`
-            };
-        }
-        // For Azure Repos (TfsGit), fetch YAML content directly
-        const response = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}/yaml?api-version=${this.apiVersion}`);
-        return {
-            definitionId,
-            project,
-            pipelineName: definition.name,
-            yamlLocation: 'azureRepos',
-            yaml: response.yaml || response
-        };
-    }
-    /**
-     * List recent pipeline runs for a definition
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @param top Maximum number of results (default: 10)
-     * @returns List of builds/runs
-     */
-    async listPipelineRuns(project, definitionId, top = 10) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/build/builds?definitions=${definitionId}&$top=${top}&api-version=${this.apiVersion}`);
-        return {
-            project,
-            definitionId,
-            totalCount: response.value.length,
-            builds: response.value.map((build) => ({
-                id: build.id,
-                buildNumber: build.buildNumber,
-                status: build.status,
-                result: build.result,
-                queueTime: build.queueTime,
-                startTime: build.startTime,
-                finishTime: build.finishTime,
-                sourceBranch: build.sourceBranch,
-                sourceVersion: build.sourceVersion,
-                requestedBy: build.requestedBy?.displayName,
-                requestedFor: build.requestedFor?.displayName,
-                reason: build.reason,
-                priority: build.priority,
-                url: build._links?.web?.href
-            }))
-        };
-    }
-    /**
-     * Get build status and details
+     * Get build status with optional timeline and logs
      * @param project The project name
      * @param buildId The build ID
-     * @param detail Level of detail: "summary" | "timeline" | "full"
-     * @param timelineScope Timeline scope: 'stages' | 'jobs' | 'all' | 'problems' (default: 'problems')
-     * @param maxIssues Maximum issues per timeline record (default: 5)
-     * @returns Build details
+     * @param detail Level of detail: 'summary', 'timeline', or 'full'
+     * @param timelineScope Scope for timeline: 'stages', 'jobs', 'all', 'problems'
+     * @param maxIssues Maximum issues per record
      */
     async getBuildStatus(project, buildId, detail = 'summary', timelineScope = 'problems', maxIssues = 5) {
         this.validateProject(project);
@@ -925,12 +795,10 @@ export class AzureDevOpsService {
             project: response.project?.name,
             url: response._links?.web?.href
         };
-        // Add timeline if requested
         if (detail === 'timeline' || detail === 'full') {
             const timeline = await this.getBuildTimeline(project, buildId, timelineScope, maxIssues);
             result.timeline = timeline;
         }
-        // Add logs if full detail requested
         if (detail === 'full') {
             const logs = await this.getBuildLogs(project, buildId);
             result.logs = logs;
@@ -938,42 +806,35 @@ export class AzureDevOpsService {
         return result;
     }
     /**
-     * Get build timeline (step-by-step breakdown)
+     * Get build timeline with step-by-step breakdown
      * @param project The project name
      * @param buildId The build ID
-     * @param scope Filter scope: 'stages' | 'jobs' | 'all' | 'problems' (default: 'problems')
-     * @param maxIssues Maximum issues per record (default: 5, prioritizes errors over warnings)
-     * @returns Build timeline with records and summary stats
+     * @param scope Filter scope: 'stages', 'jobs', 'all', 'problems'
+     * @param maxIssues Maximum issues per record
      */
     async getBuildTimeline(project, buildId, scope = 'problems', maxIssues = 5) {
         this.validateProject(project);
         const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/timeline?api-version=${this.apiVersion}`);
         const allRecords = response.records || [];
-        // Calculate summary stats from all records
         const summary = {
             total: allRecords.length,
             byType: {},
             byResult: {},
             totalErrors: 0,
             totalWarnings: 0,
-            failed: [], // Names of failed items
+            failed: [],
         };
         for (const record of allRecords) {
-            // Count by type
             summary.byType[record.type] = (summary.byType[record.type] || 0) + 1;
-            // Count by result
             if (record.result) {
                 summary.byResult[record.result] = (summary.byResult[record.result] || 0) + 1;
             }
-            // Sum errors and warnings
             summary.totalErrors += record.errorCount || 0;
             summary.totalWarnings += record.warningCount || 0;
-            // Track failed item names
             if (record.result === 'failed' || record.result === 'canceled') {
                 summary.failed.push(`${record.type}: ${record.name}`);
             }
         }
-        // Filter records based on scope
         let filteredRecords = allRecords;
         switch (scope) {
             case 'stages':
@@ -990,14 +851,11 @@ export class AzureDevOpsService {
                 break;
             case 'all':
             default:
-                // Keep all records
                 break;
         }
-        // Map and truncate issues (prioritizing errors over warnings)
         const truncateIssues = (issues, max) => {
             if (!issues || issues.length === 0)
                 return { items: [], totalCount: 0, truncated: false };
-            // Sort: errors first, then warnings, then others
             const sorted = [...issues].sort((a, b) => {
                 const priority = (issue) => {
                     if (issue.type === 'error')
@@ -1028,7 +886,7 @@ export class AzureDevOpsService {
                 order: record.order,
                 errorCount: record.errorCount,
                 warningCount: record.warningCount,
-                log: record.log ? { id: record.log.id } : null, // Removed URL to save space
+                log: record.log ? { id: record.log.id } : null,
                 issues: truncatedIssues.items,
                 issuesTruncated: truncatedIssues.truncated,
                 totalIssueCount: truncatedIssues.totalCount
@@ -1044,16 +902,14 @@ export class AzureDevOpsService {
         };
     }
     /**
-     * Get build logs
+     * Get build logs (list or specific log content)
      * @param project The project name
      * @param buildId The build ID
-     * @param logId Optional specific log ID
-     * @returns Build logs
+     * @param logId Optional specific log ID to retrieve content
      */
     async getBuildLogs(project, buildId, logId) {
         this.validateProject(project);
         if (logId !== undefined) {
-            // Get specific log content
             const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs/${logId}?api-version=${this.apiVersion}`);
             return {
                 buildId,
@@ -1062,7 +918,6 @@ export class AzureDevOpsService {
                 content: response
             };
         }
-        // Get list of all logs
         const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs?api-version=${this.apiVersion}`);
         return {
             buildId,
@@ -1078,917 +933,469 @@ export class AzureDevOpsService {
             }))
         };
     }
-    /**
-     * Create a new pipeline definition
-     * @param project The project name
-     * @param name Pipeline name
-     * @param repositoryId Repository ID
-     * @param yamlPath Path to YAML file in repository
-     * @param folder Optional folder path
-     * @returns Created pipeline definition
-     */
-    async createPipelineDefinition(project, name, repositoryId, yamlPath, folder) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        const definition = {
-            name,
-            path: folder || '\\',
-            type: 'build',
-            queueStatus: 'enabled',
-            process: {
-                type: 2, // YAML process type
-                yamlFilename: yamlPath
-            },
-            repository: {
-                id: repositoryId,
-                type: 'TfsGit'
-            }
-        };
-        const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`, 'POST', definition);
-        return {
-            id: response.id,
-            name: response.name,
-            path: response.path,
-            revision: response.revision,
-            project,
-            url: response._links?.web?.href
-        };
-    }
-    /**
-     * Update a pipeline definition
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @param updates Object with updated properties
-     * @returns Updated pipeline definition
-     */
-    async updatePipelineDefinition(project, definitionId, updates) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        // Get current definition first
-        const current = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`);
-        // Merge updates
-        const updated = {
-            ...current,
-            ...updates,
-            revision: current.revision // Must include current revision
-        };
-        const response = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`, 'PUT', updated);
-        return {
-            id: response.id,
-            name: response.name,
-            path: response.path,
-            revision: response.revision,
-            project,
-            url: response._links?.web?.href
-        };
-    }
-    /**
-     * Rename a pipeline definition
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @param newName The new name
-     * @returns Updated pipeline definition
-     */
-    async renamePipelineDefinition(project, definitionId, newName) {
-        return this.updatePipelineDefinition(project, definitionId, { name: newName });
-    }
-    /**
-     * Queue a new build
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @param branch Optional source branch
-     * @param variables Optional variables to pass
-     * @param parameters Optional pipeline parameters
-     * @returns Queued build
-     */
-    async queueBuild(project, definitionId, branch, variables, parameters) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        const buildRequest = {
-            definition: { id: definitionId }
-        };
-        if (branch) {
-            buildRequest.sourceBranch = branch;
-        }
-        if (variables) {
-            buildRequest.parameters = JSON.stringify(variables);
-        }
-        if (parameters) {
-            buildRequest.templateParameters = parameters;
-        }
-        const response = await this.makeRequest(`${project}/_apis/build/builds?api-version=${this.apiVersion}`, 'POST', buildRequest);
-        return {
-            id: response.id,
-            buildNumber: response.buildNumber,
-            status: response.status,
-            queueTime: response.queueTime,
-            definition: response.definition?.name,
-            sourceBranch: response.sourceBranch,
-            project,
-            url: response._links?.web?.href
-        };
-    }
-    /**
-     * Cancel a running build
-     * @param project The project name
-     * @param buildId The build ID
-     * @returns Cancelled build
-     */
-    async cancelBuild(project, buildId) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`, 'PATCH', { status: 'cancelling' });
-        return {
-            id: response.id,
-            buildNumber: response.buildNumber,
-            status: response.status,
-            project,
-            message: 'Build cancellation requested'
-        };
-    }
-    /**
-     * Retry a failed build
-     * @param project The project name
-     * @param buildId The build ID to retry
-     * @returns New build
-     */
-    async retryBuild(project, buildId) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        // Get the original build to get definition and source info
-        const original = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`);
-        // Queue a new build with the same parameters
-        return this.queueBuild(project, original.definition.id, original.sourceBranch);
-    }
-    /**
-     * Delete a pipeline definition
-     * @param project The project name
-     * @param definitionId The pipeline definition ID
-     * @returns Deletion confirmation
-     */
-    async deletePipelineDefinition(project, definitionId) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineDelete) {
-            throw new Error('Pipeline delete operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_DELETE=true to enable.');
-        }
-        await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            definitionId,
-            project,
-            deleted: true
-        };
-    }
     // ═══════════════════════════════════════════════════════════════════════════════
-    // SERVICE CONNECTION OPERATIONS (DevOps Admin Tools)
+    // PULL REQUEST OPERATIONS
     // ═══════════════════════════════════════════════════════════════════════════════
     /**
-     * List all service connections in a project
+     * List all Git repositories in a project
      * @param project The project name
-     * @returns List of service connections
+     * @returns List of repositories with their IDs
      */
-    async listServiceConnections(project) {
+    async listRepositories(project) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints?api-version=${this.apiVersion}`);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories?api-version=${this.apiVersion}`);
         return {
             project,
             totalCount: response.value.length,
-            serviceConnections: response.value.map((conn) => ({
-                id: conn.id,
-                name: conn.name,
-                type: conn.type,
-                url: conn.url,
-                description: conn.description,
-                isShared: conn.isShared,
-                isReady: conn.isReady,
-                owner: conn.owner,
-                createdBy: conn.createdBy?.displayName,
-                authorization: conn.authorization ? {
-                    scheme: conn.authorization.scheme,
-                    // Mask any sensitive parameters
-                    parameters: conn.authorization.parameters ?
-                        Object.keys(conn.authorization.parameters).reduce((acc, key) => {
-                            acc[key] = key.toLowerCase().includes('password') ||
-                                key.toLowerCase().includes('secret') ||
-                                key.toLowerCase().includes('key') ||
-                                key.toLowerCase().includes('token')
-                                ? '***SECRET***'
-                                : conn.authorization.parameters[key];
-                            return acc;
-                        }, {}) : {}
-                } : null
+            repositories: response.value.map((repo) => ({
+                id: repo.id,
+                name: repo.name,
+                url: repo.url,
+                defaultBranch: repo.defaultBranch,
+                size: repo.size,
+                remoteUrl: repo.remoteUrl,
+                webUrl: repo.webUrl
             }))
         };
     }
     /**
-     * Get a specific service connection
+     * List pull requests in a repository
      * @param project The project name
-     * @param connectionId The service connection ID
-     * @returns Service connection details
-     */
-    async getServiceConnection(project, connectionId) {
+     * @param repositoryId Repository ID (GUID) or name
+     * @param status Filter by status: active, completed, abandoned, all (default: active)
+     * @param top Maximum results (default: 25)
+     * @param creatorId Filter by creator ID
+     * @param reviewerId Filter by reviewer ID
+     * @returns List of pull requests
+     */
+    async listPullRequests(project, repositoryId, status = 'active', top = 25, creatorId, reviewerId) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
+        let url = `${project}/_apis/git/repositories/${repositoryId}/pullrequests?searchCriteria.status=${status}&$top=${top}&api-version=${this.apiVersion}`;
+        if (creatorId)
+            url += `&searchCriteria.creatorId=${creatorId}`;
+        if (reviewerId)
+            url += `&searchCriteria.reviewerId=${reviewerId}`;
+        const response = await this.makeRequest(url);
         return {
-            id: response.id,
-            name: response.name,
-            type: response.type,
-            url: response.url,
-            description: response.description,
-            isShared: response.isShared,
-            isReady: response.isReady,
-            owner: response.owner,
-            createdBy: response.createdBy?.displayName,
             project,
-            authorization: response.authorization ? {
-                scheme: response.authorization.scheme,
-                // Mask any sensitive parameters
-                parameters: response.authorization.parameters ?
-                    Object.keys(response.authorization.parameters).reduce((acc, key) => {
-                        acc[key] = key.toLowerCase().includes('password') ||
-                            key.toLowerCase().includes('secret') ||
-                            key.toLowerCase().includes('key') ||
-                            key.toLowerCase().includes('token')
-                            ? '***SECRET***'
-                            : response.authorization.parameters[key];
-                        return acc;
-                    }, {}) : {}
-            } : null,
-            data: response.data || {},
-            serviceEndpointProjectReferences: response.serviceEndpointProjectReferences
-        };
-    }
-    /**
-     * Get available service connection types
-     * @returns List of service connection types
-     */
-    async getServiceConnectionTypes() {
-        const response = await this.makeRequest(`_apis/serviceendpoint/types?api-version=${this.apiVersion}`);
-        return {
+            repositoryId,
+            status,
             totalCount: response.value.length,
-            types: response.value.map((type) => ({
-                name: type.name,
-                displayName: type.displayName,
-                description: type.description,
-                helpMarkDown: type.helpMarkDown,
-                authenticationSchemes: type.authenticationSchemes?.map((scheme) => ({
-                    scheme: scheme.scheme,
-                    displayName: scheme.displayName
-                })) || []
+            pullRequests: response.value.map((pr) => ({
+                pullRequestId: pr.pullRequestId,
+                title: pr.title,
+                description: pr.description ? this.truncate(pr.description, 200) : null,
+                status: pr.status,
+                createdBy: pr.createdBy?.displayName,
+                creationDate: pr.creationDate,
+                closedDate: pr.closedDate,
+                sourceBranch: pr.sourceRefName?.replace('refs/heads/', ''),
+                targetBranch: pr.targetRefName?.replace('refs/heads/', ''),
+                mergeStatus: pr.mergeStatus,
+                isDraft: pr.isDraft,
+                reviewerCount: pr.reviewers?.length || 0,
+                url: pr._links?.web?.href
             }))
         };
     }
     /**
-     * Create a new service connection
+     * Get details of a specific pull request
      * @param project The project name
-     * @param name Connection name
-     * @param type Connection type
-     * @param configuration Type-specific configuration
-     * @returns Created service connection
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @returns Pull request details with reviewers
      */
-    async createServiceConnection(project, name, type, configuration) {
+    async getPullRequest(project, repositoryId, pullRequestId) {
         this.validateProject(project);
-        if (!this.config.enableServiceConnUpsert) {
-            throw new Error('Service connection upsert operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_UPSERT=true to enable.');
-        }
-        const endpoint = {
-            name,
-            type,
-            url: configuration.url || '',
-            description: configuration.description || '',
-            authorization: configuration.authorization,
-            data: configuration.data || {},
-            isShared: false,
-            isReady: true
-        };
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints?api-version=${this.apiVersion}`, 'POST', endpoint);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}?api-version=${this.apiVersion}`);
         return {
-            id: response.id,
-            name: response.name,
-            type: response.type,
-            isReady: response.isReady,
-            project
-        };
-    }
-    /**
-     * Update a service connection
-     * @param project The project name
-     * @param connectionId The service connection ID
-     * @param updates Updated properties (not credentials)
-     * @returns Updated service connection
-     */
-    async updateServiceConnection(project, connectionId, updates) {
-        this.validateProject(project);
-        if (!this.config.enableServiceConnUpsert) {
-            throw new Error('Service connection upsert operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_UPSERT=true to enable.');
-        }
-        // Get current connection first
-        const current = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
-        // Merge updates (but don't allow overwriting authorization for security)
-        const updated = {
-            ...current,
-            name: updates.name || current.name,
-            description: updates.description || current.description,
-            url: updates.url || current.url,
-            data: updates.data ? { ...current.data, ...updates.data } : current.data
-        };
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`, 'PUT', updated);
-        return {
-            id: response.id,
-            name: response.name,
-            type: response.type,
-            isReady: response.isReady,
+            pullRequestId: response.pullRequestId,
+            title: response.title,
+            description: response.description,
+            status: response.status,
+            createdBy: {
+                displayName: response.createdBy?.displayName,
+                id: response.createdBy?.id,
+                uniqueName: response.createdBy?.uniqueName
+            },
+            creationDate: response.creationDate,
+            closedDate: response.closedDate,
+            sourceBranch: response.sourceRefName?.replace('refs/heads/', ''),
+            targetBranch: response.targetRefName?.replace('refs/heads/', ''),
+            mergeStatus: response.mergeStatus,
+            isDraft: response.isDraft,
+            mergeId: response.lastMergeCommit?.commitId,
+            sourceCommitId: response.lastMergeSourceCommit?.commitId,
+            targetCommitId: response.lastMergeTargetCommit?.commitId,
+            supportsIterations: response.supportsIterations,
+            reviewers: (response.reviewers || []).map((r) => ({
+                displayName: r.displayName,
+                id: r.id,
+                vote: r.vote,
+                voteLabel: this.getVoteLabel(r.vote),
+                isRequired: r.isRequired,
+                hasDeclined: r.hasDeclined
+            })),
+            labels: response.labels?.map((l) => l.name) || [],
+            autoComplete: response.autoCompleteSetBy ? {
+                setBy: response.autoCompleteSetBy.displayName,
+                mergeStrategy: response.completionOptions?.mergeStrategy
+            } : null,
+            url: response._links?.web?.href,
             project
         };
     }
     /**
-     * Share a service connection across projects
-     * @param connectionId The service connection ID
-     * @param projectIds Array of project IDs to share with
-     * @returns Updated service connection
+     * Convert numeric vote to label
      */
-    async shareServiceConnection(connectionId, projectIds) {
-        if (!this.config.enableServiceConnUpsert) {
-            throw new Error('Service connection upsert operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_UPSERT=true to enable.');
+    getVoteLabel(vote) {
+        switch (vote) {
+            case -10: return 'Rejected';
+            case -5: return 'Waiting for author';
+            case 0: return 'No response';
+            case 5: return 'Approved with suggestions';
+            case 10: return 'Approved';
+            default: return `Unknown (${vote})`;
         }
-        // This requires fetching the current endpoint and updating its project references
-        // Note: This is a simplified implementation - full implementation would need project name lookup
-        const shareRequest = projectIds.map(projectId => ({
-            projectReference: { id: projectId },
-            name: '' // Will be set by API
-        }));
-        const response = await this.makeRequest(`_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`, 'PATCH', { serviceEndpointProjectReferences: shareRequest });
-        return {
-            id: response.id,
-            name: response.name,
-            sharedWith: projectIds
-        };
     }
     /**
-     * Delete a service connection
+     * Get commits in a pull request
      * @param project The project name
-     * @param connectionId The service connection ID
-     * @returns Deletion confirmation
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @returns List of commits
      */
-    async deleteServiceConnection(project, connectionId) {
+    async getPullRequestCommits(project, repositoryId, pullRequestId) {
         this.validateProject(project);
-        if (!this.config.enableServiceConnDelete) {
-            throw new Error('Service connection delete operations are disabled. Set AZUREDEVOPS_ENABLE_SERVICE_CONN_DELETE=true to enable.');
-        }
-        await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`, 'DELETE');
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/commits?api-version=${this.apiVersion}`);
         return {
-            connectionId,
+            pullRequestId,
             project,
-            deleted: true
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // VARIABLE GROUP UPSERT/DELETE OPERATIONS (DevOps Admin Tools)
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * Create a new variable group
-     * @param project The project name
-     * @param name Variable group name
-     * @param description Optional description
-     * @param variables Initial variables
-     * @returns Created variable group
-     */
-    async createVariableGroup(project, name, description, variables) {
-        this.validateProject(project);
-        if (!this.config.enableVariableGroupUpsert) {
-            throw new Error('Variable group upsert operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_UPSERT=true to enable.');
-        }
-        const variableGroup = {
-            name,
-            description: description || '',
-            type: 'Vsts',
-            variables: variables || {},
-            variableGroupProjectReferences: [{
-                    projectReference: { name: project },
-                    name: name
-                }]
-        };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups?api-version=${this.apiVersion}`, 'POST', variableGroup);
-        return {
-            id: response.id,
-            name: response.name,
-            project,
-            variableCount: Object.keys(response.variables || {}).length
-        };
-    }
-    /**
-     * Update a variable group's metadata
-     * @param project The project name
-     * @param groupId The variable group ID
-     * @param updates Updated properties
-     * @returns Updated variable group
-     */
-    async updateVariableGroupMetadata(project, groupId, updates) {
-        this.validateProject(project);
-        if (!this.config.enableVariableGroupUpsert) {
-            throw new Error('Variable group upsert operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_UPSERT=true to enable.');
-        }
-        // Get current group first
-        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
-        const updated = {
-            ...current,
-            name: updates.name || current.name,
-            description: updates.description || current.description
-        };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', updated);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            project
+            totalCount: response.value.length,
+            commits: response.value.map((c) => ({
+                commitId: c.commitId,
+                comment: c.comment,
+                author: {
+                    name: c.author?.name,
+                    email: c.author?.email,
+                    date: c.author?.date
+                },
+                committer: {
+                    name: c.committer?.name,
+                    date: c.committer?.date
+                },
+                url: c.url
+            }))
         };
     }
     /**
-     * Set or update a variable in a variable group
+     * Get threads/comments on a pull request
      * @param project The project name
-     * @param groupId The variable group ID
-     * @param variableName Variable name
-     * @param value Variable value
-     * @param isSecret Whether the variable is secret
-     * @returns Updated variable group
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @returns List of discussion threads
      */
-    async setVariable(project, groupId, variableName, value, isSecret = false) {
+    async getPullRequestThreads(project, repositoryId, pullRequestId) {
         this.validateProject(project);
-        if (!this.config.enableVariableGroupUpsert) {
-            throw new Error('Variable group upsert operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_UPSERT=true to enable.');
-        }
-        // Get current group first
-        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
-        // Update the variable
-        current.variables[variableName] = { value, isSecret };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads?api-version=${this.apiVersion}`);
         return {
-            id: response.id,
-            name: response.name,
+            pullRequestId,
             project,
-            variableSet: variableName,
-            isSecret
+            totalCount: response.value.length,
+            threads: response.value.map((t) => ({
+                id: t.id,
+                status: t.status,
+                publishedDate: t.publishedDate,
+                lastUpdatedDate: t.lastUpdatedDate,
+                isDeleted: t.isDeleted,
+                threadContext: t.threadContext ? {
+                    filePath: t.threadContext.filePath,
+                    rightFileStart: t.threadContext.rightFileStart,
+                    rightFileEnd: t.threadContext.rightFileEnd
+                } : null,
+                comments: (t.comments || []).filter((c) => !c.isDeleted).map((c) => ({
+                    id: c.id,
+                    author: c.author?.displayName,
+                    content: c.content,
+                    publishedDate: c.publishedDate,
+                    commentType: c.commentType,
+                    parentCommentId: c.parentCommentId
+                }))
+            }))
         };
     }
     /**
-     * Remove a variable from a variable group
+     * Get file changes in a pull request
      * @param project The project name
-     * @param groupId The variable group ID
-     * @param variableName Variable name to remove
-     * @returns Updated variable group
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @param iterationId Iteration ID (default: latest)
+     * @returns List of changed files
      */
-    async removeVariable(project, groupId, variableName) {
+    async getPullRequestChanges(project, repositoryId, pullRequestId, iterationId) {
         this.validateProject(project);
-        if (!this.config.enableVariableGroupDelete) {
-            throw new Error('Variable group delete operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_DELETE=true to enable.');
-        }
-        // Get current group first
-        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
-        // Remove the variable
-        if (current.variables[variableName]) {
-            delete current.variables[variableName];
-        }
-        else {
-            throw new Error(`Variable '${variableName}' not found in group ${groupId}`);
+        // If no iteration specified, get the latest
+        let targetIteration = iterationId;
+        if (!targetIteration) {
+            const iterations = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/iterations?api-version=${this.apiVersion}`);
+            if (iterations.value.length > 0) {
+                targetIteration = iterations.value[iterations.value.length - 1].id;
+            }
+            else {
+                throw new Error('No iterations found for this pull request');
+            }
         }
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/iterations/${targetIteration}/changes?api-version=${this.apiVersion}`);
         return {
-            id: response.id,
-            name: response.name,
+            pullRequestId,
+            iterationId: targetIteration,
             project,
-            variableRemoved: variableName
+            totalCount: response.changeEntries?.length || 0,
+            changes: (response.changeEntries || []).map((c) => ({
+                changeType: c.changeType,
+                path: c.item?.path,
+                originalPath: c.originalPath,
+                objectId: c.item?.objectId,
+                originalObjectId: c.item?.originalObjectId
+            }))
         };
     }
     /**
-     * Delete a variable group
+     * Add a comment thread to a pull request
      * @param project The project name
-     * @param groupId The variable group ID
-     * @returns Deletion confirmation
-     */
-    async deleteVariableGroup(project, groupId) {
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @param content Comment content (markdown supported)
+     * @param filePath Optional file path for inline comment
+     * @param lineNumber Optional line number (right side) for inline comment
+     * @param status Thread status: active, fixed, wontFix, closed, byDesign, pending (default: active)
+     * @returns Created thread
+     */
+    async addPullRequestThread(project, repositoryId, pullRequestId, content, filePath, lineNumber, status = 'active') {
         this.validateProject(project);
-        if (!this.config.enableVariableGroupDelete) {
-            throw new Error('Variable group delete operations are disabled. Set AZUREDEVOPS_ENABLE_VARIABLE_GROUP_DELETE=true to enable.');
-        }
-        await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            groupId,
-            project,
-            deleted: true
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // AGENT POOL OPERATIONS (DevOps Admin Tools)
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * List all agent pools
-     * @param poolType Optional filter: "automation" or "deployment"
-     * @returns List of agent pools
-     */
-    async listAgentPools(poolType) {
-        let url = `_apis/distributedtask/pools?api-version=${this.apiVersion}`;
-        if (poolType) {
-            url += `&poolType=${poolType}`;
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
+        }
+        const threadData = {
+            comments: [
+                {
+                    parentCommentId: 0,
+                    content: content,
+                    commentType: 1 // 1 = text
+                }
+            ],
+            status: status
+        };
+        // Add file context for inline comments
+        if (filePath && lineNumber) {
+            threadData.threadContext = {
+                filePath: filePath.startsWith('/') ? filePath : `/${filePath}`,
+                rightFileStart: { line: lineNumber, offset: 1 },
+                rightFileEnd: { line: lineNumber, offset: 1 }
+            };
         }
-        const response = await this.makeRequest(url);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads?api-version=${this.apiVersion}`, 'POST', threadData);
         return {
-            totalCount: response.value.length,
-            pools: response.value.map((pool) => ({
-                id: pool.id,
-                name: pool.name,
-                size: pool.size,
-                isHosted: pool.isHosted,
-                poolType: pool.poolType,
-                createdBy: pool.createdBy?.displayName,
-                createdOn: pool.createdOn,
-                autoProvision: pool.autoProvision,
-                autoUpdate: pool.autoUpdate,
-                autoSize: pool.autoSize,
-                targetSize: pool.targetSize
-            }))
-        };
-    }
-    /**
-     * Get a specific agent pool
-     * @param poolId The pool ID
-     * @returns Agent pool details
-     */
-    async getAgentPool(poolId) {
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}?api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            size: response.size,
-            isHosted: response.isHosted,
-            poolType: response.poolType,
-            createdBy: response.createdBy?.displayName,
-            createdOn: response.createdOn,
-            autoProvision: response.autoProvision,
-            autoUpdate: response.autoUpdate,
-            autoSize: response.autoSize,
-            targetSize: response.targetSize,
-            owner: response.owner?.displayName,
-            agentCloudId: response.agentCloudId,
-            properties: response.properties
-        };
-    }
-    /**
-     * List agents in a pool
-     * @param poolId The pool ID
-     * @param includeCapabilities Include agent capabilities
-     * @returns List of agents
-     */
-    async listAgents(poolId, includeCapabilities = false) {
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents?includeCapabilities=${includeCapabilities}&api-version=${this.apiVersion}`);
-        return {
-            poolId,
-            totalCount: response.value.length,
-            agents: response.value.map((agent) => ({
-                id: agent.id,
-                name: agent.name,
-                version: agent.version,
-                osDescription: agent.osDescription,
-                enabled: agent.enabled,
-                status: agent.status,
-                provisioningState: agent.provisioningState,
-                createdOn: agent.createdOn,
-                maxParallelism: agent.maxParallelism,
-                systemCapabilities: includeCapabilities ? agent.systemCapabilities : undefined,
-                userCapabilities: includeCapabilities ? agent.userCapabilities : undefined
-            }))
-        };
-    }
-    /**
-     * Get a specific agent
-     * @param poolId The pool ID
-     * @param agentId The agent ID
-     * @returns Agent details
-     */
-    async getAgent(poolId, agentId) {
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?includeCapabilities=true&api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            version: response.version,
-            osDescription: response.osDescription,
-            enabled: response.enabled,
+            threadId: response.id,
             status: response.status,
-            provisioningState: response.provisioningState,
-            accessPoint: response.accessPoint,
-            createdOn: response.createdOn,
-            maxParallelism: response.maxParallelism,
-            systemCapabilities: response.systemCapabilities,
-            userCapabilities: response.userCapabilities,
-            assignedRequest: response.assignedRequest,
-            lastCompletedRequest: response.lastCompletedRequest
-        };
-    }
-    /**
-     * Update an agent pool
-     * @param poolId The pool ID
-     * @param updates Updated settings
-     * @returns Updated agent pool
-     */
-    async updateAgentPool(poolId, updates) {
-        if (!this.config.enableAgentPoolUpsert) {
-            throw new Error('Agent pool upsert operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_UPSERT=true to enable.');
-        }
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}?api-version=${this.apiVersion}`, 'PATCH', updates);
-        return {
-            id: response.id,
-            name: response.name,
-            autoProvision: response.autoProvision,
-            autoUpdate: response.autoUpdate,
-            autoSize: response.autoSize,
-            targetSize: response.targetSize
+            publishedDate: response.publishedDate,
+            filePath: response.threadContext?.filePath,
+            comments: response.comments?.map((c) => ({
+                id: c.id,
+                content: c.content,
+                author: c.author?.displayName
+            })),
+            message: filePath
+                ? `Inline comment added to ${filePath} at line ${lineNumber}`
+                : 'Comment thread created',
+            pullRequestId,
+            project
         };
     }
     /**
-     * Enable a disabled agent
-     * @param poolId The pool ID
-     * @param agentId The agent ID
-     * @returns Updated agent
+     * Create a new pull request
      */
-    async enableAgent(poolId, agentId) {
-        if (!this.config.enableAgentPoolUpsert) {
-            throw new Error('Agent pool upsert operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_UPSERT=true to enable.');
+    async createPullRequest(project, repositoryId, sourceRefName, targetRefName, title, description, reviewerIds, isDraft) {
+        this.validateProject(project);
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
         }
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?api-version=${this.apiVersion}`, 'PATCH', { enabled: true });
-        return {
-            id: response.id,
-            name: response.name,
-            enabled: response.enabled,
-            status: response.status
+        const body = {
+            sourceRefName,
+            targetRefName,
+            title,
+            description: description || '',
+            isDraft: isDraft || false,
         };
-    }
-    /**
-     * Disable an agent
-     * @param poolId The pool ID
-     * @param agentId The agent ID
-     * @returns Updated agent
-     */
-    async disableAgent(poolId, agentId) {
-        if (!this.config.enableAgentPoolDisable) {
-            throw new Error('Agent pool disable operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_DISABLE=true to enable.');
+        if (reviewerIds && reviewerIds.length > 0) {
+            body.reviewers = reviewerIds.map(id => ({ id }));
         }
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?api-version=${this.apiVersion}`, 'PATCH', { enabled: false });
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests?api-version=${this.apiVersion}`, 'POST', body, false, { 'Content-Type': 'application/json' });
         return {
-            id: response.id,
-            name: response.name,
-            enabled: response.enabled,
+            pullRequestId: response.pullRequestId,
+            title: response.title,
             status: response.status,
-            message: 'Agent disabled - will complete current job then stop accepting new jobs'
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // ENVIRONMENT OPERATIONS (DevOps Admin Tools)
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * List all environments in a project
-     * @param project The project name
-     * @returns List of environments
-     */
-    async listEnvironments(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            environments: response.value.map((env) => ({
-                id: env.id,
-                name: env.name,
-                description: env.description,
-                createdBy: env.createdBy?.displayName,
-                createdOn: env.createdOn,
-                lastModifiedBy: env.lastModifiedBy?.displayName,
-                lastModifiedOn: env.lastModifiedOn
-            }))
-        };
-    }
-    /**
-     * Get a specific environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @returns Environment details
-     */
-    async getEnvironment(project, environmentId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?expands=resourceReferences&api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
+            isDraft: response.isDraft,
+            sourceBranch: response.sourceRefName?.replace('refs/heads/', ''),
+            targetBranch: response.targetRefName?.replace('refs/heads/', ''),
             createdBy: response.createdBy?.displayName,
-            createdOn: response.createdOn,
-            lastModifiedBy: response.lastModifiedBy?.displayName,
-            lastModifiedOn: response.lastModifiedOn,
-            project,
-            resources: response.resources || []
-        };
-    }
-    /**
-     * Get deployment history for an environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @param top Maximum number of results
-     * @returns Deployment records
-     */
-    async getEnvironmentDeployments(project, environmentId, top = 10) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}/environmentdeploymentrecords?top=${top}&api-version=${this.apiVersion}`);
-        return {
-            project,
-            environmentId,
-            totalCount: response.value.length,
-            deployments: response.value.map((dep) => ({
-                id: dep.id,
-                environmentId: dep.environmentId,
-                definition: dep.definition ? {
-                    id: dep.definition.id,
-                    name: dep.definition.name
-                } : null,
-                owner: dep.owner?.displayName,
-                planType: dep.planType,
-                startTime: dep.startTime,
-                finishTime: dep.finishTime,
-                result: dep.result,
-                queueTime: dep.queueTime
-            }))
+            creationDate: response.creationDate,
+            url: response.url,
+            project
         };
     }
     /**
-     * Create a new environment
-     * @param project The project name
-     * @param name Environment name
-     * @param description Optional description
-     * @returns Created environment
+     * Update an existing pull request (title, description, status, draft)
      */
-    async createEnvironment(project, name, description) {
+    async updatePullRequest(project, repositoryId, pullRequestId, updates) {
         this.validateProject(project);
-        if (!this.config.enableEnvironmentUpsert) {
-            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
-        }
-        const environment = {
-            name,
-            description: description || ''
-        };
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments?api-version=${this.apiVersion}`, 'POST', environment);
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
+        }
+        const body = {};
+        if (updates.title !== undefined)
+            body.title = updates.title;
+        if (updates.description !== undefined)
+            body.description = updates.description;
+        if (updates.status !== undefined)
+            body.status = updates.status;
+        if (updates.isDraft !== undefined)
+            body.isDraft = updates.isDraft;
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}?api-version=${this.apiVersion}`, 'PATCH', body, false, { 'Content-Type': 'application/json' });
         return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
+            pullRequestId: response.pullRequestId,
+            title: response.title,
+            description: response.description ? this.truncate(response.description, 200) : null,
+            status: response.status,
+            isDraft: response.isDraft,
             project
         };
     }
     /**
-     * Update an environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @param updates Updated properties
-     * @returns Updated environment
+     * Complete (merge) a pull request
      */
-    async updateEnvironment(project, environmentId, updates) {
+    async completePullRequest(project, repositoryId, pullRequestId, mergeStrategy = 'squash', deleteSourceBranch = true, transitionWorkItems = true, mergeCommitMessage) {
         this.validateProject(project);
-        if (!this.config.enableEnvironmentUpsert) {
-            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
+        }
+        // Fetch current PR to get lastMergeSourceCommit
+        const currentPr = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}?api-version=${this.apiVersion}`);
+        const mergeStrategyMap = {
+            noFastForward: 1,
+            squash: 2,
+            rebase: 3,
+            rebaseMerge: 4,
+        };
+        const body = {
+            status: 'completed',
+            lastMergeSourceCommit: currentPr.lastMergeSourceCommit,
+            completionOptions: {
+                mergeStrategy: mergeStrategyMap[mergeStrategy],
+                deleteSourceBranch,
+                transitionWorkItems,
+            },
+        };
+        if (mergeCommitMessage) {
+            body.completionOptions.mergeCommitMessage = mergeCommitMessage;
         }
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'PATCH', updates);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}?api-version=${this.apiVersion}`, 'PATCH', body, false, { 'Content-Type': 'application/json' });
         return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
+            pullRequestId: response.pullRequestId,
+            title: response.title,
+            status: response.status,
+            mergeStrategy,
+            closedDate: response.closedDate,
             project
         };
     }
     /**
-     * Delete an environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @returns Deletion confirmation
+     * Add or remove a reviewer from a pull request
      */
-    async deleteEnvironment(project, environmentId) {
+    async addOrRemovePrReviewer(project, repositoryId, pullRequestId, reviewerId, isRequired, remove) {
         this.validateProject(project);
-        if (!this.config.enableEnvironmentDelete) {
-            throw new Error('Environment delete operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_DELETE=true to enable.');
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
         }
-        await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            environmentId,
-            project,
-            deleted: true
-        };
-    }
-    /**
-     * Get all checks configured for an environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @returns List of check configurations
-     */
-    async getEnvironmentChecks(project, environmentId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations?resourceType=environment&resourceId=${environmentId}&api-version=7.1-preview.1`);
-        return {
-            project,
-            environmentId,
-            totalCount: response.value.length,
-            checks: response.value.map((check) => ({
-                id: check.id,
-                type: check.type?.name || check.type?.id,
-                settings: check.settings,
-                timeout: check.timeout,
-                retryInterval: check.retryInterval,
-                createdBy: check.createdBy?.displayName,
-                createdOn: check.createdOn,
-                modifiedBy: check.modifiedBy?.displayName,
-                modifiedOn: check.modifiedOn,
-                resource: check.resource
-            }))
-        };
-    }
-    /**
-     * Add a check to an environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @param checkType The type of check (e.g., "Approval", "ExclusiveLock")
-     * @param configuration Check configuration
-     * @returns Created check
-     */
-    async addEnvironmentCheck(project, environmentId, checkType, configuration) {
-        this.validateProject(project);
-        if (!this.config.enableEnvironmentUpsert) {
-            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        const url = `${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/reviewers/${reviewerId}?api-version=${this.apiVersion}`;
+        if (remove) {
+            await this.makeRequest(url, 'DELETE');
+            return { pullRequestId, reviewerId, action: 'removed', project };
         }
-        const check = {
-            type: { name: checkType },
-            settings: configuration,
-            resource: {
-                type: 'environment',
-                id: String(environmentId)
-            }
-        };
-        const response = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations?api-version=7.1-preview.1`, 'POST', check);
+        const body = { id: reviewerId };
+        if (isRequired !== undefined) {
+            body.isRequired = isRequired;
+        }
+        const response = await this.makeRequest(url, 'PUT', body, false, { 'Content-Type': 'application/json' });
         return {
-            id: response.id,
-            type: response.type?.name,
-            environmentId,
+            pullRequestId,
+            reviewerId: response.id,
+            displayName: response.displayName,
+            isRequired: response.isRequired,
+            vote: response.vote,
+            action: 'added',
             project
         };
     }
     /**
-     * Update an existing environment check
-     * @param project The project name
-     * @param checkId The check configuration ID
-     * @param updates Updated settings and/or timeout
-     * @returns Updated check
+     * Submit a vote on a pull request
      */
-    async updateEnvironmentCheck(project, checkId, updates) {
+    async votePullRequest(project, repositoryId, pullRequestId, vote, reviewerId) {
         this.validateProject(project);
-        if (!this.config.enableEnvironmentUpsert) {
-            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
+        }
+        const voteMap = {
+            approve: 10,
+            approveWithSuggestions: 5,
+            noResponse: 0,
+            waitForAuthor: -5,
+            reject: -10,
+        };
+        // If no reviewerId, resolve authenticated user
+        let userId = reviewerId;
+        if (!userId) {
+            const connectionData = await this.makeRequest('_apis/connectionData');
+            userId = connectionData.authenticatedUser?.id;
+            if (!userId) {
+                throw new Error('Could not resolve authenticated user ID. Provide reviewerId explicitly.');
+            }
         }
-        // Get current check configuration first
-        const current = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`);
-        // Merge updates
-        const updated = {
-            ...current,
-            settings: updates.settings !== undefined ? updates.settings : current.settings,
-            timeout: updates.timeout !== undefined ? updates.timeout : current.timeout
-        };
-        const response = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`, 'PATCH', updated);
+        const body = { vote: voteMap[vote] };
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/reviewers/${userId}?api-version=${this.apiVersion}`, 'PUT', body, false, { 'Content-Type': 'application/json' });
         return {
-            id: response.id,
-            type: response.type?.name,
-            settings: response.settings,
-            timeout: response.timeout,
+            pullRequestId,
+            reviewerId: response.id,
+            displayName: response.displayName,
+            vote: response.vote,
+            voteLabel: vote,
             project
         };
     }
     /**
-     * Remove a check from an environment
-     * @param project The project name
-     * @param checkId The check configuration ID
-     * @returns Deletion confirmation
+     * Reply to a PR thread and optionally update thread status
      */
-    async removeEnvironmentCheck(project, checkId) {
+    async replyToPrThread(project, repositoryId, pullRequestId, threadId, content, status) {
         this.validateProject(project);
-        if (!this.config.enableEnvironmentDelete) {
-            throw new Error('Environment delete operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_DELETE=true to enable.');
+        if (!this.config.enablePullRequestWrite) {
+            throw new Error('Pull request write operations are disabled. Set AZUREDEVOPS_ENABLE_PR_WRITE=true to enable.');
+        }
+        const results = { pullRequestId, threadId, project };
+        // Add reply comment if content provided
+        if (content) {
+            const commentResponse = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads/${threadId}/comments?api-version=${this.apiVersion}`, 'POST', { content, parentCommentId: 0, commentType: 1 }, false, { 'Content-Type': 'application/json' });
+            results.comment = {
+                id: commentResponse.id,
+                content: commentResponse.content,
+                author: commentResponse.author?.displayName,
+            };
         }
-        await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`, 'DELETE');
-        return {
-            checkId,
-            project,
-            deleted: true
-        };
+        // Update thread status if provided
+        if (status) {
+            await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads/${threadId}?api-version=${this.apiVersion}`, 'PATCH', { status }, false, { 'Content-Type': 'application/json' });
+            results.status = status;
+        }
+        return results;
     }
 }
 //# sourceMappingURL=AzureDevOpsService.js.map