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

package/build/AzureDevOpsService.js

@@ -13,20 +13,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}`;
@@ -739,1256 +726,283 @@ export class AzureDevOpsService {
         };
     }
     // ═══════════════════════════════════════════════════════════════════════════════
-    // PIPELINE/BUILD OPERATIONS (DevOps Admin Tools)
+    // PULL REQUEST OPERATIONS
     // ═══════════════════════════════════════════════════════════════════════════════
     /**
-     * List all pipeline definitions in a project
+     * List all Git repositories in a project
      * @param project The project name
-     * @returns List of pipeline definitions
+     * @returns List of repositories with their IDs
      */
-    async listPipelineDefinitions(project) {
+    async listRepositories(project) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories?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
-     * @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
-     */
-    async getBuildStatus(project, buildId, detail = 'summary', timelineScope = 'problems', maxIssues = 5) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`);
-        const result = {
-            id: response.id,
-            buildNumber: response.buildNumber,
-            status: response.status,
-            result: response.result,
-            queueTime: response.queueTime,
-            startTime: response.startTime,
-            finishTime: response.finishTime,
-            sourceBranch: response.sourceBranch,
-            sourceVersion: response.sourceVersion,
-            definition: response.definition ? {
-                id: response.definition.id,
-                name: response.definition.name
-            } : null,
-            requestedBy: response.requestedBy?.displayName,
-            requestedFor: response.requestedFor?.displayName,
-            reason: response.reason,
-            priority: response.priority,
-            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;
-        }
-        return result;
-    }
-    /**
-     * Get build timeline (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
-     */
-    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
-        };
-        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':
-                filteredRecords = allRecords.filter((r) => r.type === 'Stage');
-                break;
-            case 'jobs':
-                filteredRecords = allRecords.filter((r) => r.type === 'Stage' || r.type === 'Job');
-                break;
-            case 'problems':
-                filteredRecords = allRecords.filter((r) => (r.errorCount && r.errorCount > 0) ||
-                    (r.warningCount && r.warningCount > 0) ||
-                    r.result === 'failed' ||
-                    r.result === 'canceled');
-                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')
-                        return 0;
-                    if (issue.type === 'warning')
-                        return 1;
-                    return 2;
-                };
-                return priority(a) - priority(b);
-            });
-            return {
-                items: sorted.slice(0, max),
-                totalCount: issues.length,
-                truncated: issues.length > max
-            };
-        };
-        const mappedRecords = filteredRecords.map((record) => {
-            const truncatedIssues = truncateIssues(record.issues, maxIssues);
-            return {
-                id: record.id,
-                parentId: record.parentId,
-                type: record.type,
-                name: record.name,
-                state: record.state,
-                result: record.result,
-                startTime: record.startTime,
-                finishTime: record.finishTime,
-                order: record.order,
-                errorCount: record.errorCount,
-                warningCount: record.warningCount,
-                log: record.log ? { id: record.log.id } : null, // Removed URL to save space
-                issues: truncatedIssues.items,
-                issuesTruncated: truncatedIssues.truncated,
-                totalIssueCount: truncatedIssues.totalCount
-            };
-        });
-        return {
-            buildId,
-            project,
-            scope,
-            summary,
-            recordCount: mappedRecords.length,
-            records: mappedRecords
-        };
-    }
-    /**
-     * Get build logs
-     * @param project The project name
-     * @param buildId The build ID
-     * @param logId Optional specific log ID
-     * @returns Build logs
-     */
-    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,
-                logId,
-                project,
-                content: response
-            };
-        }
-        // Get list of all logs
-        const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs?api-version=${this.apiVersion}`);
-        return {
-            buildId,
-            project,
-            totalCount: response.value.length,
-            logs: response.value.map((log) => ({
-                id: log.id,
-                type: log.type,
-                lineCount: log.lineCount,
-                createdOn: log.createdOn,
-                lastChangedOn: log.lastChangedOn,
-                url: log.url
+            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
             }))
         };
     }
     /**
-     * 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)
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * List all service connections in a project
+     * List pull requests in a repository
      * @param project The project name
-     * @returns List of service connections
+     * @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 listServiceConnections(project) {
+    async listPullRequests(project, repositoryId, status = 'active', top = 25, creatorId, reviewerId) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints?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 {
             project,
+            repositoryId,
+            status,
             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
+            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
             }))
         };
     }
     /**
-     * Get a specific service connection
+     * Get details of a specific pull request
      * @param project The project name
-     * @param connectionId The service connection ID
-     * @returns Service connection details
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @returns Pull request details with reviewers
      */
-    async getServiceConnection(project, connectionId) {
+    async getPullRequest(project, repositoryId, pullRequestId) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
+        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,
-            url: response.url,
+            pullRequestId: response.pullRequestId,
+            title: response.title,
             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;
-                    }, {}) : {}
+            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,
-            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 {
-            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
-                })) || []
-            }))
-        };
-    }
-    /**
-     * Create a new service connection
-     * @param project The project name
-     * @param name Connection name
-     * @param type Connection type
-     * @param configuration Type-specific configuration
-     * @returns Created service connection
-     */
-    async createServiceConnection(project, name, type, configuration) {
-        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);
-        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,
-            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
-     */
-    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.');
-        }
-        // 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
-     * @param project The project name
-     * @param connectionId The service connection ID
-     * @returns Deletion confirmation
-     */
-    async deleteServiceConnection(project, connectionId) {
-        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');
-        return {
-            connectionId,
-            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,
+            url: response._links?.web?.href,
             project
         };
     }
     /**
-     * Set or update a variable in a variable group
-     * @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
-     */
-    async setVariable(project, groupId, variableName, value, isSecret = false) {
-        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);
-        return {
-            id: response.id,
-            name: response.name,
-            project,
-            variableSet: variableName,
-            isSecret
-        };
-    }
-    /**
-     * Remove a variable from a variable group
-     * @param project The project name
-     * @param groupId The variable group ID
-     * @param variableName Variable name to remove
-     * @returns Updated variable group
-     */
-    async removeVariable(project, groupId, variableName) {
-        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}`);
-        }
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
-        return {
-            id: response.id,
-            name: response.name,
-            project,
-            variableRemoved: variableName
-        };
-    }
-    /**
-     * Delete a variable group
-     * @param project The project name
-     * @param groupId The variable group ID
-     * @returns Deletion confirmation
-     */
-    async deleteVariableGroup(project, groupId) {
-        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}`;
-        }
-        const response = await this.makeRequest(url);
-        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,
-            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
+     * Convert numeric vote to label
      */
-    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.');
+    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})`;
         }
-        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
-        };
     }
     /**
-     * Enable a disabled agent
-     * @param poolId The pool ID
-     * @param agentId The agent ID
-     * @returns Updated agent
-     */
-    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.');
-        }
-        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
-        };
-    }
-    /**
-     * 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.');
-        }
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}/agents/${agentId}?api-version=${this.apiVersion}`, 'PATCH', { enabled: false });
-        return {
-            id: response.id,
-            name: response.name,
-            enabled: response.enabled,
-            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
+     * Get commits in a pull request
      * @param project The project name
-     * @returns List of environments
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @returns List of commits
      */
-    async listEnvironments(project) {
+    async getPullRequestCommits(project, repositoryId, pullRequestId) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments?api-version=${this.apiVersion}`);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/commits?api-version=${this.apiVersion}`);
         return {
+            pullRequestId,
             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
+            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
             }))
         };
     }
     /**
-     * Get a specific environment
+     * Get threads/comments on a pull request
      * @param project The project name
-     * @param environmentId The environment ID
-     * @returns Environment details
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @returns List of discussion threads
      */
-    async getEnvironment(project, environmentId) {
+    async getPullRequestThreads(project, repositoryId, pullRequestId) {
         this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?expands=resourceReferences&api-version=${this.apiVersion}`);
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads?api-version=${this.apiVersion}`);
         return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            createdBy: response.createdBy?.displayName,
-            createdOn: response.createdOn,
-            lastModifiedBy: response.lastModifiedBy?.displayName,
-            lastModifiedOn: response.lastModifiedOn,
+            pullRequestId,
             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
+            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,
-                owner: dep.owner?.displayName,
-                planType: dep.planType,
-                startTime: dep.startTime,
-                finishTime: dep.finishTime,
-                result: dep.result,
-                queueTime: dep.queueTime
+                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
+                }))
             }))
         };
     }
     /**
-     * Create a new environment
-     * @param project The project name
-     * @param name Environment name
-     * @param description Optional description
-     * @returns Created environment
-     */
-    async createEnvironment(project, name, description) {
-        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);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            project
-        };
-    }
-    /**
-     * Update an environment
-     * @param project The project name
-     * @param environmentId The environment ID
-     * @param updates Updated properties
-     * @returns Updated environment
-     */
-    async updateEnvironment(project, environmentId, 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 response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'PATCH', updates);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            project
-        };
-    }
-    /**
-     * Delete an environment
+     * Get file changes in a pull request
      * @param project The project name
-     * @param environmentId The environment ID
-     * @returns Deletion confirmation
+     * @param repositoryId Repository ID (GUID) or name
+     * @param pullRequestId The PR ID
+     * @param iterationId Iteration ID (default: latest)
+     * @returns List of changed files
      */
-    async deleteEnvironment(project, environmentId) {
+    async getPullRequestChanges(project, repositoryId, pullRequestId, iterationId) {
         this.validateProject(project);
-        if (!this.config.enableEnvironmentDelete) {
-            throw new Error('Environment delete operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_DELETE=true to enable.');
+        // 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');
+            }
         }
-        await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'DELETE');
+        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/iterations/${targetIteration}/changes?api-version=${this.apiVersion}`);
         return {
-            environmentId,
+            pullRequestId,
+            iterationId: targetIteration,
             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
+            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
             }))
         };
     }
     /**
-     * Add a check to an environment
+     * Add a comment thread to a pull request
      * @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
+     * @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 addEnvironmentCheck(project, environmentId, checkType, configuration) {
+    async addPullRequestThread(project, repositoryId, pullRequestId, content, filePath, lineNumber, status = 'active') {
         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 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);
-        return {
-            id: response.id,
-            type: response.type?.name,
-            environmentId,
-            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
-     */
-    async updateEnvironmentCheck(project, checkId, 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 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 }
+            };
         }
-        // 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 response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads?api-version=${this.apiVersion}`, 'POST', threadData);
         return {
-            id: response.id,
-            type: response.type?.name,
-            settings: response.settings,
-            timeout: response.timeout,
+            threadId: response.id,
+            status: response.status,
+            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
         };
     }
-    /**
-     * Remove a check from an environment
-     * @param project The project name
-     * @param checkId The check configuration ID
-     * @returns Deletion confirmation
-     */
-    async removeEnvironmentCheck(project, checkId) {
-        this.validateProject(project);
-        if (!this.config.enableEnvironmentDelete) {
-            throw new Error('Environment delete operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_DELETE=true to enable.');
-        }
-        await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`, 'DELETE');
-        return {
-            checkId,
-            project,
-            deleted: true
-        };
-    }
 }
 //# sourceMappingURL=AzureDevOpsService.js.map