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

package/build/AzureDevOpsService.js

@@ -1,1558 +0,0 @@
-import axios from 'axios';
-import { marked } from 'marked';
-import { getAllLargeTextFields } from './sync/html-detection.js';
-export class AzureDevOpsService {
-    config;
-    baseUrl;
-    searchUrl;
-    authHeader;
-    apiVersion;
-    constructor(config) {
-        this.config = {
-            ...config,
-            apiVersion: config.apiVersion || '7.1',
-            enableWorkItemWrite: config.enableWorkItemWrite ?? false,
-            enableWorkItemDelete: config.enableWorkItemDelete ?? false,
-            enableWikiWrite: config.enableWikiWrite ?? false,
-            enableWikiDelete: config.enableWikiDelete ?? false,
-            enablePullRequestWrite: config.enablePullRequestWrite ?? false,
-        };
-        this.baseUrl = `https://dev.azure.com/${this.config.organization}`;
-        this.searchUrl = `https://almsearch.dev.azure.com/${this.config.organization}`;
-        this.apiVersion = this.config.apiVersion;
-        // Encode PAT for Basic Auth (format is :PAT encoded in base64)
-        this.authHeader = `Basic ${Buffer.from(`:${this.config.pat}`).toString('base64')}`;
-    }
-    /**
-     * Validate that a project is in the allowed list
-     */
-    validateProject(project) {
-        if (!this.config.projects.includes(project)) {
-            throw new Error(`Project '${project}' is not in the allowed projects list. Allowed projects: ${this.config.projects.join(', ')}`);
-        }
-    }
-    /**
-     * Make an authenticated request to the Azure DevOps API
-     */
-    async makeRequest(endpoint, method = 'GET', data, useSearchUrl = false, customHeaders) {
-        try {
-            const baseUrl = useSearchUrl ? this.searchUrl : this.baseUrl;
-            const url = `${baseUrl}/${endpoint}`;
-            const response = await axios({
-                method,
-                url,
-                headers: {
-                    'Authorization': this.authHeader,
-                    'Content-Type': method === 'PATCH' ? 'application/json-patch+json' : 'application/json',
-                    'Accept': 'application/json',
-                    ...customHeaders // Merge custom headers (can override defaults)
-                },
-                data
-            });
-            return response.data;
-        }
-        catch (error) {
-            const errorDetails = error.response?.data?.message || error.response?.data || error.message;
-            console.error('Azure DevOps API request failed:', {
-                endpoint,
-                method,
-                status: error.response?.status,
-                statusText: error.response?.statusText,
-                error: errorDetails
-            });
-            // Provide user-friendly error messages
-            if (error.response?.status === 401) {
-                throw new Error('Azure DevOps authentication failed. Please check your PAT token and permissions.');
-            }
-            if (error.response?.status === 403) {
-                throw new Error('Azure DevOps access denied. Please check your PAT scopes and project permissions.');
-            }
-            if (error.response?.status === 404) {
-                throw new Error(`Azure DevOps resource not found: ${endpoint}`);
-            }
-            throw new Error(`Azure DevOps API request failed: ${error.message} - ${JSON.stringify(errorDetails)}`);
-        }
-    }
-    // ==================== WIKI OPERATIONS ====================
-    /**
-     * Convert a git path (returned by search) to a wiki path (used by get-page API)
-     * Git paths use dashes and .md extensions: /Release-Notes/Page-Name.md
-     * Wiki paths use spaces and no extensions: /Release Notes/Page Name
-     * @param gitPath The git path from search results
-     * @returns The wiki path for use with get-page API
-     */
-    convertGitPathToWikiPath(gitPath) {
-        return gitPath
-            .replace(/\.md$/, '') // Remove .md extension
-            .replace(/-/g, ' ') // Replace ALL dashes with spaces
-            .replace(/%2D/gi, '-'); // Decode %2D back to - (actual dashes in page names)
-    }
-    /**
-     * Count occurrences of a string in content
-     * @param content The content to search in
-     * @param searchStr The string to search for
-     * @returns Number of occurrences
-     */
-    countOccurrences(content, searchStr) {
-        const regex = new RegExp(this.escapeRegExp(searchStr), 'g');
-        const matches = content.match(regex);
-        return matches ? matches.length : 0;
-    }
-    /**
-     * Get locations where a string appears in content
-     * @param content The content to search in
-     * @param searchStr The string to search for
-     * @returns Formatted string showing line numbers and context
-     */
-    getMatchLocations(content, searchStr) {
-        const lines = content.split('\n');
-        const matches = [];
-        lines.forEach((line, index) => {
-            if (line.includes(searchStr)) {
-                matches.push(`Line ${index + 1}: ${this.truncate(line.trim(), 100)}`);
-            }
-        });
-        const maxDisplay = 10;
-        const result = matches.slice(0, maxDisplay).join('\n');
-        if (matches.length > maxDisplay) {
-            return result + `\n... and ${matches.length - maxDisplay} more`;
-        }
-        return result;
-    }
-    /**
-     * Generate a unified diff showing changes
-     * @param oldContent Original content
-     * @param newContent Updated content
-     * @param oldStr The string that was replaced
-     * @param newStr The replacement string
-     * @returns Formatted diff output
-     */
-    generateUnifiedDiff(oldContent, newContent, oldStr, newStr) {
-        const oldLines = oldContent.split('\n');
-        const newLines = newContent.split('\n');
-        // Find changed lines
-        const changedLineNumbers = [];
-        oldLines.forEach((line, index) => {
-            if (line.includes(oldStr)) {
-                changedLineNumbers.push(index);
-            }
-        });
-        // Build diff output
-        const diffLines = [];
-        changedLineNumbers.forEach(lineNum => {
-            diffLines.push(`@@ Line ${lineNum + 1} @@`);
-            diffLines.push(`- ${oldLines[lineNum]}`);
-            diffLines.push(`+ ${newLines[lineNum]}`);
-            diffLines.push('');
-        });
-        return diffLines.join('\n');
-    }
-    /**
-     * Escape special regex characters
-     * @param str String to escape
-     * @returns Escaped string safe for use in regex
-     */
-    escapeRegExp(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-    /**
-     * Truncate a string for display
-     * @param str String to truncate
-     * @param maxLen Maximum length
-     * @returns Truncated string with ellipsis if needed
-     */
-    truncate(str, maxLen) {
-        return str.length > maxLen ? str.substring(0, maxLen) + '...' : str;
-    }
-    /**
-     * Get all wikis in a project
-     * @param project The project name
-     * @returns List of wikis in the project
-     */
-    async getWikis(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/wiki/wikis?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            wikis: response.value.map((wiki) => ({
-                id: wiki.id,
-                name: wiki.name,
-                type: wiki.type,
-                url: wiki.url,
-                projectId: wiki.projectId,
-                repositoryId: wiki.repositoryId,
-                mappedPath: wiki.mappedPath
-            }))
-        };
-    }
-    /**
-     * Search wiki pages across projects
-     * @param searchText The text to search for
-     * @param project Optional project filter
-     * @param maxResults Maximum number of results (default: 25)
-     * @returns Search results with highlighted content
-     */
-    async searchWikiPages(searchText, project, maxResults = 25) {
-        if (project) {
-            this.validateProject(project);
-        }
-        const searchBody = {
-            searchText,
-            $top: maxResults,
-            $skip: 0
-        };
-        // Add project filter if specified
-        if (project) {
-            searchBody.filters = {
-                Project: [project]
-            };
-        }
-        const response = await this.makeRequest(`_apis/search/wikisearchresults?api-version=${this.apiVersion}`, 'POST', searchBody, true // Use search URL
-        );
-        return {
-            searchText,
-            project: project || 'all',
-            totalCount: response.count || 0,
-            results: (response.results || []).map((result) => {
-                const gitPath = result.path;
-                const wikiPath = this.convertGitPathToWikiPath(gitPath);
-                return {
-                    fileName: result.fileName,
-                    gitPath: gitPath, // Original git path (for reference)
-                    path: wikiPath, // Wiki path (for get-page API) - kept as 'path' for backward compatibility
-                    wikiName: result.wiki?.name,
-                    wikiId: result.wiki?.id,
-                    project: result.project?.name,
-                    highlights: result.hits?.map((hit) => hit.highlights).flat() || []
-                };
-            })
-        };
-    }
-    /**
-     * Get a specific wiki page with content
-     * @param project The project name
-     * @param wikiId The wiki identifier (ID or name)
-     * @param pagePath The path to the page (e.g., "/Setup/Authentication")
-     *                 Accepts both wiki paths (with spaces) and git paths (with dashes and .md)
-     * @param includeContent Include page content (default: true)
-     * @returns Wiki page with content and metadata
-     */
-    async getWikiPage(project, wikiId, pagePath, includeContent = true) {
-        this.validateProject(project);
-        // Always normalize paths to wiki format (removes .md, converts dashes to spaces)
-        // This ensures consistent behavior regardless of input format
-        const wikiPath = this.convertGitPathToWikiPath(pagePath);
-        // Log conversion if the path was changed (for debugging)
-        if (wikiPath !== pagePath) {
-            console.error(`Normalized wiki path: ${pagePath} -> ${wikiPath}`);
-        }
-        // Use axios directly to access response headers (for ETag)
-        const url = `${this.baseUrl}/${project}/_apis/wiki/wikis/${wikiId}/pages?path=${encodeURIComponent(wikiPath)}&includeContent=${includeContent}&api-version=${this.apiVersion}`;
-        try {
-            const axiosResponse = await axios({
-                method: 'GET',
-                url,
-                headers: {
-                    'Authorization': this.authHeader,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json'
-                }
-            });
-            const response = axiosResponse.data;
-            // Extract ETag from response headers (needed for updates)
-            const etag = axiosResponse.headers['etag'] || axiosResponse.headers['ETag'];
-            // The API returns the page data directly (not wrapped in a 'page' property)
-            return {
-                id: response.id,
-                path: response.path,
-                content: response.content,
-                gitItemPath: response.gitItemPath,
-                subPages: response.subPages || [],
-                url: response.url,
-                remoteUrl: response.remoteUrl,
-                version: etag, // Include ETag for use with updateWikiPage
-                project,
-                wikiId
-            };
-        }
-        catch (error) {
-            // Handle errors similar to makeRequest
-            const errorDetails = error.response?.data?.message || error.response?.data || error.message;
-            console.error('Azure DevOps API request failed:', {
-                url,
-                status: error.response?.status,
-                error: errorDetails
-            });
-            if (error.response?.status === 401) {
-                throw new Error('Azure DevOps authentication failed. Please check your PAT token and permissions.');
-            }
-            if (error.response?.status === 403) {
-                throw new Error('Azure DevOps access denied. Please check your PAT scopes and project permissions.');
-            }
-            if (error.response?.status === 404) {
-                throw new Error(`Wiki page not found: ${wikiPath} (original input: ${pagePath})`);
-            }
-            throw new Error(`Azure DevOps API request failed: ${error.message} - ${JSON.stringify(errorDetails)}`);
-        }
-    }
-    /**
-     * Create a new wiki page
-     * @param project The project name
-     * @param wikiId The wiki identifier
-     * @param pagePath The path for the new page (will be normalized to wiki format)
-     * @param content The markdown content
-     * @returns Created page information
-     */
-    async createWikiPage(project, wikiId, pagePath, content) {
-        this.validateProject(project);
-        if (!this.config.enableWikiWrite) {
-            throw new Error('Wiki write operations are disabled. Set AZUREDEVOPS_ENABLE_WIKI_WRITE=true to enable.');
-        }
-        // Always normalize paths to wiki format (removes .md, converts dashes to spaces)
-        const wikiPath = this.convertGitPathToWikiPath(pagePath);
-        // Log conversion if the path was changed (for debugging)
-        if (wikiPath !== pagePath) {
-            console.error(`Normalized wiki path for creation: ${pagePath} -> ${wikiPath}`);
-        }
-        const response = await this.makeRequest(`${project}/_apis/wiki/wikis/${wikiId}/pages?path=${encodeURIComponent(wikiPath)}&api-version=${this.apiVersion}`, 'PUT', { content });
-        return {
-            id: response.page?.id,
-            path: response.page?.path,
-            gitItemPath: response.page?.gitItemPath,
-            project,
-            wikiId
-        };
-    }
-    /**
-     * Update an existing wiki page
-     * @param project The project name
-     * @param wikiId The wiki identifier
-     * @param pagePath The path to the page (will be normalized to wiki format)
-     * @param content The updated markdown content
-     * @param version The ETag/version for optimistic concurrency. If not provided, will be auto-fetched from current page.
-     * @returns Updated page information
-     */
-    async updateWikiPage(project, wikiId, pagePath, content, version) {
-        this.validateProject(project);
-        if (!this.config.enableWikiWrite) {
-            throw new Error('Wiki write operations are disabled. Set AZUREDEVOPS_ENABLE_WIKI_WRITE=true to enable.');
-        }
-        // Always normalize paths to wiki format (removes .md, converts dashes to spaces)
-        const wikiPath = this.convertGitPathToWikiPath(pagePath);
-        // Log conversion if the path was changed (for debugging)
-        if (wikiPath !== pagePath) {
-            console.error(`Normalized wiki path for update: ${pagePath} -> ${wikiPath}`);
-        }
-        // Auto-fetch version if not provided (required for updating existing pages)
-        if (!version) {
-            try {
-                const currentPage = await this.getWikiPage(project, wikiId, wikiPath, false);
-                version = currentPage.version;
-                if (version) {
-                    console.error(`Auto-fetched version for wiki update: ${version}`);
-                }
-                else {
-                    console.error(`Warning: getWikiPage returned no version/etag for existing page. Response: ${JSON.stringify(currentPage)}`);
-                }
-            }
-            catch (error) {
-                // If page doesn't exist, proceed without version (will create new page)
-                const errorMsg = error.message?.toLowerCase() || '';
-                if (!errorMsg.includes('not found') && !errorMsg.includes('404') && !errorMsg.includes('does not exist')) {
-                    throw error;
-                }
-                console.error(`Page not found, will create new page: ${wikiPath}`);
-            }
-        }
-        // Add If-Match header if version is available (for optimistic concurrency control)
-        const customHeaders = version ? { 'If-Match': version } : undefined;
-        const response = await this.makeRequest(`${project}/_apis/wiki/wikis/${wikiId}/pages?path=${encodeURIComponent(wikiPath)}&api-version=${this.apiVersion}`, 'PUT', { content }, false, // useSearchUrl
-        customHeaders);
-        return {
-            id: response.page?.id,
-            path: response.page?.path,
-            gitItemPath: response.page?.gitItemPath,
-            project,
-            wikiId
-        };
-    }
-    /**
-     * Replace a specific string in a wiki page without rewriting entire content
-     * @param project The project name
-     * @param wikiId The wiki identifier
-     * @param pagePath The path to the page (will be normalized to wiki format)
-     * @param oldStr The exact string to replace
-     * @param newStr The replacement string
-     * @param replaceAll If true, replace all occurrences; if false, old_str must be unique
-     * @param description Optional description of the change for audit logging
-     * @returns Result with diff, occurrence count, version, and message
-     */
-    async strReplaceWikiPage(project, wikiId, pagePath, oldStr, newStr, replaceAll = false, description) {
-        this.validateProject(project);
-        // 1. Validate write permission
-        if (!this.config.enableWikiWrite) {
-            throw new Error('Wiki write operations are disabled. Set AZUREDEVOPS_ENABLE_WIKI_WRITE=true to enable.');
-        }
-        // 2. Fetch current page content and version (auto-fetch latest)
-        const currentPage = await this.getWikiPage(project, wikiId, pagePath, true);
-        const currentContent = currentPage.content;
-        const currentVersion = currentPage.version;
-        // 3. Count occurrences of old_str
-        const occurrences = this.countOccurrences(currentContent, oldStr);
-        if (occurrences === 0) {
-            throw new Error(`String not found in page.\n\n` +
-                `Looking for: "${this.truncate(oldStr, 200)}"\n\n` +
-                `Page excerpt:\n${this.truncate(currentContent, 500)}`);
-        }
-        if (occurrences > 1 && !replaceAll) {
-            throw new Error(`String appears ${occurrences} times in the page. ` +
-                `Either provide more context to make old_str unique, or set replace_all=true.\n\n` +
-                `Matching locations:\n${this.getMatchLocations(currentContent, oldStr)}`);
-        }
-        // 4. Perform replacement
-        const regex = new RegExp(this.escapeRegExp(oldStr), replaceAll ? 'g' : '');
-        const newContent = currentContent.replace(regex, newStr);
-        // 5. Validate replacement succeeded
-        if (newContent === currentContent) {
-            throw new Error('Replacement failed - content unchanged');
-        }
-        // 6. Update wiki page with version conflict retry
-        let updateResult;
-        try {
-            updateResult = await this.updateWikiPage(project, wikiId, pagePath, newContent, currentVersion);
-        }
-        catch (error) {
-            // Version conflict - retry once with fresh version
-            if (error.message.includes('412') || error.message.includes('version') || error.message.includes('conflict')) {
-                console.error('Version conflict detected, retrying with fresh version...');
-                const freshPage = await this.getWikiPage(project, wikiId, pagePath, true);
-                const freshContent = freshPage.content;
-                const freshVersion = freshPage.version;
-                // Re-apply replacement to fresh content
-                const freshRegex = new RegExp(this.escapeRegExp(oldStr), replaceAll ? 'g' : '');
-                const freshNewContent = freshContent.replace(freshRegex, newStr);
-                updateResult = await this.updateWikiPage(project, wikiId, pagePath, freshNewContent, freshVersion);
-            }
-            else {
-                throw error;
-            }
-        }
-        // 7. Generate diff output
-        const diff = this.generateUnifiedDiff(currentContent, newContent, oldStr, newStr);
-        // 8. Return result with diff
-        return {
-            success: true,
-            diff,
-            occurrences: replaceAll ? occurrences : 1,
-            version: currentVersion,
-            message: `Successfully replaced ${replaceAll ? occurrences : 1} occurrence(s)`,
-            ...updateResult
-        };
-    }
-    /**
-     * Delete a wiki page permanently
-     * @param project The project name
-     * @param wikiId The wiki identifier
-     * @param pagePath The path to the page (used as-is, no conversion applied)
-     * @returns Deletion confirmation
-     */
-    async deleteWikiPage(project, wikiId, pagePath) {
-        this.validateProject(project);
-        if (!this.config.enableWikiDelete) {
-            throw new Error('Wiki delete operations are disabled. Set AZUREDEVOPS_ENABLE_WIKI_DELETE=true to enable.');
-        }
-        // NOTE: Unlike other wiki methods, we do NOT convert the path here.
-        // The user provides the actual wiki path (with hyphens, spaces, etc.) directly.
-        // Converting hyphens to spaces would break paths with dates (e.g., "2026-02-03")
-        // or other legitimate hyphens in page names.
-        await this.makeRequest(`${project}/_apis/wiki/wikis/${wikiId}/pages?path=${encodeURIComponent(pagePath)}&api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            project,
-            wikiId,
-            pagePath: pagePath,
-            deleted: true
-        };
-    }
-    // ==================== WORK ITEM OPERATIONS ====================
-    /**
-     * Get a work item by ID with full details
-     * @param project The project name
-     * @param workItemId The work item ID
-     * @returns Complete work item details
-     */
-    async getWorkItem(project, workItemId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/wit/workitems/${workItemId}?$expand=all&api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            rev: response.rev,
-            url: response.url,
-            fields: response.fields,
-            relations: response.relations || [],
-            _links: response._links,
-            commentVersionRef: response.commentVersionRef,
-            project
-        };
-    }
-    /**
-     * Query work items using WIQL (Work Item Query Language)
-     * @param project The project name
-     * @param wiql The WIQL query string
-     * @param maxResults Maximum number of results (default: 200)
-     * @returns Work items matching the query
-     */
-    async queryWorkItems(project, wiql, maxResults = 200) {
-        this.validateProject(project);
-        // Execute WIQL query
-        const queryResult = await this.makeRequest(`${project}/_apis/wit/wiql?api-version=${this.apiVersion}`, 'POST', { query: wiql });
-        if (!queryResult.workItems || queryResult.workItems.length === 0) {
-            return {
-                query: wiql,
-                project,
-                totalCount: 0,
-                workItems: []
-            };
-        }
-        // Get work item IDs (limit to maxResults)
-        const workItemIds = queryResult.workItems
-            .slice(0, maxResults)
-            .map((wi) => wi.id);
-        // Batch get full work item details
-        const workItems = await this.makeRequest(`${project}/_apis/wit/workitemsbatch?api-version=${this.apiVersion}`, 'POST', {
-            ids: workItemIds,
-            $expand: 'all'
-        });
-        return {
-            query: wiql,
-            project,
-            totalCount: workItems.value.length,
-            workItems: workItems.value
-        };
-    }
-    static SUMMARY_FIELDS = [
-        'System.Id',
-        'System.Title',
-        'System.AssignedTo',
-        'System.State',
-        'Microsoft.VSTS.Common.Severity',
-        'Microsoft.VSTS.Common.Priority',
-        'System.Tags',
-        'Microsoft.VSTS.Scheduling.StoryPoints',
-        'Microsoft.VSTS.Common.ResolvedReason',
-        'System.WorkItemType',
-    ];
-    async runSavedQuery(project, queryId, maxResults = 50, detail = 'summary', fields, groupBy) {
-        this.validateProject(project);
-        const queryResult = await this.makeRequest(`${project}/_apis/wit/wiql/${queryId}?api-version=${this.apiVersion}`, 'GET');
-        if (!queryResult.workItems || queryResult.workItems.length === 0) {
-            return {
-                queryId,
-                project,
-                totalCount: 0,
-                queriedCount: queryResult.workItems?.length ?? 0,
-                workItems: [],
-            };
-        }
-        const totalAvailable = queryResult.workItems.length;
-        const workItemIds = queryResult.workItems
-            .slice(0, maxResults)
-            .map((wi) => wi.id);
-        const isFull = detail === 'full';
-        const requestedFields = fields ?? (isFull ? undefined : AzureDevOpsService.SUMMARY_FIELDS);
-        const body = { ids: workItemIds };
-        if (requestedFields) {
-            body.fields = requestedFields;
-        }
-        else {
-            body.$expand = 'all';
-        }
-        const workItems = await this.makeRequest(`${project}/_apis/wit/workitemsbatch?api-version=${this.apiVersion}`, 'POST', body);
-        const items = workItems.value.map((wi) => {
-            if (isFull && !fields)
-                return wi;
-            const f = wi.fields || {};
-            return {
-                id: wi.id,
-                type: f['System.WorkItemType'],
-                title: f['System.Title'],
-                assignedTo: f['System.AssignedTo']?.displayName ?? f['System.AssignedTo'] ?? null,
-                state: f['System.State'],
-                severity: f['Microsoft.VSTS.Common.Severity'] ?? null,
-                priority: f['Microsoft.VSTS.Common.Priority'] ?? null,
-                tags: f['System.Tags'] ?? null,
-                storyPoints: f['Microsoft.VSTS.Scheduling.StoryPoints'] ?? null,
-                resolvedReason: f['Microsoft.VSTS.Common.ResolvedReason'] ?? null,
-                ...(fields ? Object.fromEntries(Object.entries(f).filter(([k]) => !AzureDevOpsService.SUMMARY_FIELDS.includes(k))) : {}),
-            };
-        });
-        const result = {
-            queryId,
-            project,
-            totalAvailable,
-            returnedCount: items.length,
-            detail,
-        };
-        if (groupBy) {
-            const groups = {};
-            for (const item of items) {
-                const key = item[groupBy] ?? item.state ?? 'Unknown';
-                if (!groups[key])
-                    groups[key] = [];
-                groups[key].push(item);
-            }
-            result.groupedBy = groupBy;
-            result.groups = Object.fromEntries(Object.entries(groups).map(([k, v]) => [k, { count: v.length, items: v }]));
-        }
-        else {
-            result.workItems = items;
-        }
-        return result;
-    }
-    async getSavedQuery(project, queryId) {
-        this.validateProject(project);
-        return this.makeRequest(`${project}/_apis/wit/queries/${queryId}?api-version=${this.apiVersion}`, 'GET');
-    }
-    /**
-     * Get comments/discussion for a work item
-     * @param project The project name
-     * @param workItemId The work item ID
-     * @returns List of comments
-     */
-    async getWorkItemComments(project, workItemId) {
-        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`);
-        // v7.1 Comments API returns array in response.comments, not response.value
-        const comments = response.comments || response.value || [];
-        return {
-            workItemId,
-            project,
-            totalCount: response.totalCount ?? comments.length,
-            comments: comments.map((comment) => ({
-                id: comment.id,
-                text: comment.text,
-                createdBy: comment.createdBy?.displayName,
-                createdDate: comment.createdDate,
-                modifiedBy: comment.modifiedBy?.displayName,
-                modifiedDate: comment.modifiedDate,
-                url: comment.url
-            }))
-        };
-    }
-    /**
-     * Add a comment to a work item
-     * @param project The project name
-     * @param workItemId The work item ID
-     * @param commentText The comment text (supports markdown)
-     * @returns Created comment information
-     */
-    async addWorkItemComment(project, workItemId, commentText) {
-        this.validateProject(project);
-        if (!this.config.enableWorkItemWrite) {
-            throw new Error('Work item write operations are disabled. Set AZUREDEVOPS_ENABLE_WORK_ITEM_WRITE=true to enable.');
-        }
-        // Convert Markdown to HTML if configured for legacy orgs
-        let finalText = commentText;
-        const format = this.config.commentFormat || 'markdown';
-        if (format === 'html') {
-            // Convert Markdown to HTML for organizations without Markdown preview
-            finalText = await marked.parse(commentText);
-        }
-        // 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`, 'POST', { text: finalText });
-        return {
-            id: response.id,
-            workItemId,
-            project,
-            text: response.text,
-            format: format,
-            createdBy: response.createdBy?.displayName,
-            createdDate: response.createdDate
-        };
-    }
-    /**
-     * Update a work item using JSON Patch operations
-     * @param project The project name
-     * @param workItemId The work item ID
-     * @param patchOperations Array of JSON Patch operations
-     * @returns Updated work item
-     */
-    async updateWorkItem(project, workItemId, patchOperations) {
-        this.validateProject(project);
-        if (!this.config.enableWorkItemWrite) {
-            throw new Error('Work item write operations are disabled. Set AZUREDEVOPS_ENABLE_WORK_ITEM_WRITE=true to enable.');
-        }
-        const response = await this.makeRequest(`${project}/_apis/wit/workitems/${workItemId}?api-version=${this.apiVersion}`, 'PATCH', patchOperations);
-        return {
-            id: response.id,
-            rev: response.rev,
-            fields: response.fields,
-            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
-     * @param workItemType The work item type (e.g., "Bug", "Task", "User Story")
-     * @param fields Object with field values (e.g., { "System.Title": "Bug title" })
-     * @param parentId Optional parent work item ID (for creating child items)
-     * @param relations Optional array of work item relationships
-     * @returns Created work item
-     */
-    async createWorkItem(project, workItemType, fields, parentId, relations) {
-        this.validateProject(project);
-        if (!this.config.enableWorkItemWrite) {
-            throw new Error('Work item write operations are disabled. Set AZUREDEVOPS_ENABLE_WORK_ITEM_WRITE=true to enable.');
-        }
-        // Build patch operations array
-        const patchOperations = [];
-        // Add field operations
-        Object.keys(fields).forEach(field => {
-            patchOperations.push({
-                op: 'add',
-                path: `/fields/${field}`,
-                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}`;
-            patchOperations.push({
-                op: 'add',
-                path: '/relations/-',
-                value: {
-                    rel: 'System.LinkTypes.Hierarchy-Reverse',
-                    url: parentUrl
-                }
-            });
-        }
-        // Handle relations array (advanced relationships)
-        if (relations && relations.length > 0) {
-            relations.forEach(relation => {
-                patchOperations.push({
-                    op: 'add',
-                    path: '/relations/-',
-                    value: relation
-                });
-            });
-        }
-        const response = await this.makeRequest(`${project}/_apis/wit/workitems/$${workItemType}?api-version=${this.apiVersion}`, 'PATCH', patchOperations);
-        return {
-            id: response.id,
-            rev: response.rev,
-            fields: response.fields,
-            relations: response.relations || [], // Include relations in response
-            url: response._links?.html?.href,
-            project
-        };
-    }
-    /**
-     * Delete a work item
-     * @param project The project name
-     * @param workItemId The work item ID
-     * @returns Deletion confirmation
-     */
-    async deleteWorkItem(project, workItemId) {
-        this.validateProject(project);
-        if (!this.config.enableWorkItemDelete) {
-            throw new Error('Work item delete operations are disabled. Set AZUREDEVOPS_ENABLE_WORK_ITEM_DELETE=true to enable.');
-        }
-        await this.makeRequest(`${project}/_apis/wit/workitems/${workItemId}?api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            workItemId,
-            project,
-            deleted: true
-        };
-    }
-    // ==================== VARIABLE GROUP OPERATIONS ====================
-    /**
-     * Get all variable groups in a project
-     * @param project The project name
-     * @returns List of variable groups with their variables
-     */
-    async getVariableGroups(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            variableGroups: response.value.map((group) => ({
-                id: group.id,
-                name: group.name,
-                description: group.description,
-                type: group.type,
-                createdBy: group.createdBy?.displayName,
-                createdOn: group.createdOn,
-                modifiedBy: group.modifiedBy?.displayName,
-                modifiedOn: group.modifiedOn,
-                isShared: group.isShared,
-                variableGroupProjectReferences: group.variableGroupProjectReferences,
-                // Include variable names but mask secret values
-                variables: Object.keys(group.variables || {}).reduce((acc, key) => {
-                    const variable = group.variables[key];
-                    acc[key] = {
-                        value: variable.isSecret ? '***SECRET***' : variable.value,
-                        isSecret: variable.isSecret || false,
-                        isReadOnly: variable.isReadOnly || false
-                    };
-                    return acc;
-                }, {})
-            }))
-        };
-    }
-    /**
-     * Get a specific variable group by ID
-     * @param project The project name
-     * @param groupId The variable group ID
-     * @returns Variable group details with variables
-     */
-    async getVariableGroup(project, groupId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            type: response.type,
-            createdBy: response.createdBy?.displayName,
-            createdOn: response.createdOn,
-            modifiedBy: response.modifiedBy?.displayName,
-            modifiedOn: response.modifiedOn,
-            isShared: response.isShared,
-            variableGroupProjectReferences: response.variableGroupProjectReferences,
-            project,
-            // Include variable names but mask secret values
-            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,
-                    isReadOnly: variable.isReadOnly || false
-                };
-                return acc;
-            }, {})
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // 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
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * 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', 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);
-        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
-        };
-        if (detail === 'timeline' || detail === 'full') {
-            const timeline = await this.getBuildTimeline(project, buildId, timelineScope, maxIssues);
-            result.timeline = timeline;
-        }
-        if (detail === 'full') {
-            const logs = await this.getBuildLogs(project, buildId);
-            result.logs = logs;
-        }
-        return result;
-    }
-    /**
-     * 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'
-     * @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 || [];
-        const summary = {
-            total: allRecords.length,
-            byType: {},
-            byResult: {},
-            totalErrors: 0,
-            totalWarnings: 0,
-            failed: [],
-        };
-        for (const record of allRecords) {
-            summary.byType[record.type] = (summary.byType[record.type] || 0) + 1;
-            if (record.result) {
-                summary.byResult[record.result] = (summary.byResult[record.result] || 0) + 1;
-            }
-            summary.totalErrors += record.errorCount || 0;
-            summary.totalWarnings += record.warningCount || 0;
-            if (record.result === 'failed' || record.result === 'canceled') {
-                summary.failed.push(`${record.type}: ${record.name}`);
-            }
-        }
-        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:
-                break;
-        }
-        const truncateIssues = (issues, max) => {
-            if (!issues || issues.length === 0)
-                return { items: [], totalCount: 0, truncated: false };
-            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,
-                issues: truncatedIssues.items,
-                issuesTruncated: truncatedIssues.truncated,
-                totalIssueCount: truncatedIssues.totalCount
-            };
-        });
-        return {
-            buildId,
-            project,
-            scope,
-            summary,
-            recordCount: mappedRecords.length,
-            records: mappedRecords
-        };
-    }
-    /**
-     * Filter log content to reduce noise from progress indicators
-     * @param content Raw log content string
-     * @param mode Filter mode: 'summary' removes progress, 'errors' shows only errors, 'full' returns everything
-     */
-    filterLogContent(content, mode) {
-        const lines = content.split('\n');
-        const originalLineCount = lines.length;
-        if (mode === 'full') {
-            return { filtered: content, originalLineCount, filteredLineCount: originalLineCount };
-        }
-        // Progress indicator patterns to remove in summary mode
-        const PROGRESS_PATTERNS = [
-            /remote: Counting objects:\s+\d+%/,
-            /remote: Compressing objects:\s+\d+%/,
-            /Receiving objects:\s+\d+%/,
-            /Resolving deltas:\s+\d+%/,
-            /Unpacking objects:\s+\d+%/,
-            /Updating files:\s+\d+%/,
-        ];
-        // Error/warning patterns for errors mode
-        const ERROR_PATTERNS = [
-            /##\[error\]/i,
-            /##\[warning\]/i,
-            /\berror\b.*:/i,
-            /\bfailed\b/i,
-            /\bexception\b/i,
-            /\bfatal\b/i,
-        ];
-        const filteredLines = lines.filter(line => {
-            // Remove timestamp prefix for pattern matching
-            const trimmedLine = line.replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s*/, '');
-            if (mode === 'errors') {
-                return ERROR_PATTERNS.some(p => p.test(trimmedLine));
-            }
-            // summary mode: exclude progress indicators, keep everything else
-            return !PROGRESS_PATTERNS.some(p => p.test(trimmedLine));
-        });
-        return {
-            filtered: filteredLines.join('\n'),
-            originalLineCount,
-            filteredLineCount: filteredLines.length
-        };
-    }
-    /**
-     * Get build logs (list or specific log content)
-     * @param project The project name
-     * @param buildId The build ID
-     * @param logId Optional specific log ID to retrieve content
-     * @param mode Filter mode: 'summary' (default) removes progress indicators, 'full' returns everything, 'errors' shows only errors/warnings
-     */
-    async getBuildLogs(project, buildId, logId, mode = 'summary') {
-        this.validateProject(project);
-        if (logId !== undefined) {
-            const response = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/logs/${logId}?api-version=${this.apiVersion}`);
-            const { filtered, originalLineCount, filteredLineCount } = this.filterLogContent(response, mode);
-            return {
-                buildId,
-                logId,
-                project,
-                mode,
-                originalLineCount,
-                filteredLineCount,
-                content: filtered
-            };
-        }
-        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
-            }))
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // PULL REQUEST OPERATIONS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * List all Git repositories in a project
-     * @param project The project name
-     * @returns List of repositories with their IDs
-     */
-    async listRepositories(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/git/repositories?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            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
-            }))
-        };
-    }
-    /**
-     * List pull requests in a repository
-     * @param project The project name
-     * @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);
-        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,
-            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 details of a specific pull request
-     * @param project The project name
-     * @param repositoryId Repository ID (GUID) or name
-     * @param pullRequestId The PR ID
-     * @returns Pull request details with reviewers
-     */
-    async getPullRequest(project, repositoryId, pullRequestId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}?api-version=${this.apiVersion}`);
-        return {
-            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
-        };
-    }
-    /**
-     * Convert numeric vote to label
-     */
-    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})`;
-        }
-    }
-    /**
-     * Get commits in a pull request
-     * @param project The project name
-     * @param repositoryId Repository ID (GUID) or name
-     * @param pullRequestId The PR ID
-     * @returns List of commits
-     */
-    async getPullRequestCommits(project, repositoryId, pullRequestId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/commits?api-version=${this.apiVersion}`);
-        return {
-            pullRequestId,
-            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
-            }))
-        };
-    }
-    /**
-     * Get threads/comments on a pull request
-     * @param project The project name
-     * @param repositoryId Repository ID (GUID) or name
-     * @param pullRequestId The PR ID
-     * @returns List of discussion threads
-     */
-    async getPullRequestThreads(project, repositoryId, pullRequestId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads?api-version=${this.apiVersion}`);
-        return {
-            pullRequestId,
-            project,
-            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
-                }))
-            }))
-        };
-    }
-    /**
-     * Get file changes in a pull request
-     * @param project The project name
-     * @param repositoryId Repository ID (GUID) or name
-     * @param pullRequestId The PR ID
-     * @param iterationId Iteration ID (default: latest)
-     * @returns List of changed files
-     */
-    async getPullRequestChanges(project, repositoryId, pullRequestId, iterationId) {
-        this.validateProject(project);
-        // 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/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/iterations/${targetIteration}/changes?api-version=${this.apiVersion}`);
-        return {
-            pullRequestId,
-            iterationId: targetIteration,
-            project,
-            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 comment thread to a pull request
-     * @param project The project name
-     * @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.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(`${project}/_apis/git/repositories/${repositoryId}/pullrequests/${pullRequestId}/threads?api-version=${this.apiVersion}`, 'POST', threadData);
-        return {
-            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
-        };
-    }
-    /**
-     * Create a new pull request
-     */
-    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 body = {
-            sourceRefName,
-            targetRefName,
-            title,
-            description: description || '',
-            isDraft: isDraft || false,
-        };
-        if (reviewerIds && reviewerIds.length > 0) {
-            body.reviewers = reviewerIds.map(id => ({ id }));
-        }
-        const response = await this.makeRequest(`${project}/_apis/git/repositories/${repositoryId}/pullrequests?api-version=${this.apiVersion}`, 'POST', body, false, { 'Content-Type': 'application/json' });
-        return {
-            pullRequestId: response.pullRequestId,
-            title: response.title,
-            status: response.status,
-            isDraft: response.isDraft,
-            sourceBranch: response.sourceRefName?.replace('refs/heads/', ''),
-            targetBranch: response.targetRefName?.replace('refs/heads/', ''),
-            createdBy: response.createdBy?.displayName,
-            creationDate: response.creationDate,
-            url: response.url,
-            project
-        };
-    }
-    /**
-     * Update an existing pull request (title, description, status, draft)
-     */
-    async updatePullRequest(project, repositoryId, pullRequestId, updates) {
-        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 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 {
-            pullRequestId: response.pullRequestId,
-            title: response.title,
-            description: response.description ? this.truncate(response.description, 200) : null,
-            status: response.status,
-            isDraft: response.isDraft,
-            project
-        };
-    }
-    /**
-     * Complete (merge) a pull request
-     */
-    async completePullRequest(project, repositoryId, pullRequestId, mergeStrategy = 'squash', deleteSourceBranch = true, transitionWorkItems = true, mergeCommitMessage) {
-        this.validateProject(project);
-        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/git/repositories/${repositoryId}/pullrequests/${pullRequestId}?api-version=${this.apiVersion}`, 'PATCH', body, false, { 'Content-Type': 'application/json' });
-        return {
-            pullRequestId: response.pullRequestId,
-            title: response.title,
-            status: response.status,
-            mergeStrategy,
-            closedDate: response.closedDate,
-            project
-        };
-    }
-    /**
-     * Add or remove a reviewer from a pull request
-     */
-    async addOrRemovePrReviewer(project, repositoryId, pullRequestId, reviewerId, isRequired, remove) {
-        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 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 body = { id: reviewerId };
-        if (isRequired !== undefined) {
-            body.isRequired = isRequired;
-        }
-        const response = await this.makeRequest(url, 'PUT', body, false, { 'Content-Type': 'application/json' });
-        return {
-            pullRequestId,
-            reviewerId: response.id,
-            displayName: response.displayName,
-            isRequired: response.isRequired,
-            vote: response.vote,
-            action: 'added',
-            project
-        };
-    }
-    /**
-     * Submit a vote on a pull request
-     */
-    async votePullRequest(project, repositoryId, pullRequestId, vote, reviewerId) {
-        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 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.');
-            }
-        }
-        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 {
-            pullRequestId,
-            reviewerId: response.id,
-            displayName: response.displayName,
-            vote: response.vote,
-            voteLabel: vote,
-            project
-        };
-    }
-    /**
-     * Reply to a PR thread and optionally update thread status
-     */
-    async replyToPrThread(project, repositoryId, pullRequestId, threadId, content, status) {
-        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 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,
-            };
-        }
-        // 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