@mcp-consultant-tools/azure-devops-admin 33.0.0 → 35.0.0-beta.1

package/build/AzureDevOpsAdminService.js

@@ -1,1494 +0,0 @@
-import axios from 'axios';
-export class AzureDevOpsAdminService {
-    config;
-    baseUrl;
-    feedsUrl;
-    authHeader;
-    apiVersion;
-    constructor(config) {
-        this.config = {
-            ...config,
-            apiVersion: config.apiVersion || '7.1',
-            enablePipelineUpsert: config.enablePipelineUpsert ?? false,
-            enablePipelineDelete: config.enablePipelineDelete ?? false,
-            enableServiceConnUpsert: config.enableServiceConnUpsert ?? false,
-            enableServiceConnDelete: config.enableServiceConnDelete ?? false,
-            enableVariableGroupUpsert: config.enableVariableGroupUpsert ?? false,
-            enableVariableGroupDelete: config.enableVariableGroupDelete ?? false,
-            enableAgentPoolUpsert: config.enableAgentPoolUpsert ?? false,
-            enableAgentPoolDisable: config.enableAgentPoolDisable ?? false,
-            enableEnvironmentUpsert: config.enableEnvironmentUpsert ?? false,
-            enableEnvironmentDelete: config.enableEnvironmentDelete ?? false,
-            enableClassificationNodeUpsert: config.enableClassificationNodeUpsert ?? false,
-            enableClassificationNodeDelete: config.enableClassificationNodeDelete ?? false,
-        };
-        this.baseUrl = `https://dev.azure.com/${this.config.organization}`;
-        this.feedsUrl = `https://feeds.dev.azure.com/${this.config.organization}`;
-        this.apiVersion = this.config.apiVersion;
-        this.authHeader = `Basic ${Buffer.from(`:${this.config.pat}`).toString('base64')}`;
-    }
-    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(', ')}`);
-        }
-    }
-    validateFeed(feedName) {
-        if (this.config.feeds && this.config.feeds.length > 0
-            && !this.config.feeds.includes(feedName)) {
-            throw new Error(`Feed '${feedName}' is not in the allowed feeds list. ` +
-                `Allowed feeds: ${this.config.feeds.join(', ')}`);
-        }
-    }
-    /**
-     * Converts a date string to ISO 8601 format with time component.
-     * Azure DevOps Classification Nodes API requires full ISO 8601 format.
-     * Input: "2026-02-16" → Output: "2026-02-16T00:00:00Z"
-     */
-    formatDateForAdo(dateStr) {
-        // If already has time component, return as-is
-        if (dateStr.includes('T')) {
-            return dateStr;
-        }
-        // Add time component (midnight UTC)
-        return `${dateStr}T00:00:00Z`;
-    }
-    async makeRequest(endpoint, method = 'GET', data, customHeaders, contentType, baseUrlOverride) {
-        try {
-            const url = `${baseUrlOverride || this.baseUrl}/${endpoint}`;
-            // Determine content type: explicit override > default based on method
-            // Note: Most PATCH endpoints use json-patch+json, but some (like classification nodes) use regular json
-            const defaultContentType = method === 'PATCH' ? 'application/json-patch+json' : 'application/json';
-            const response = await axios({
-                method,
-                url,
-                headers: {
-                    'Authorization': this.authHeader,
-                    'Content-Type': contentType || defaultContentType,
-                    'Accept': 'application/json',
-                    ...customHeaders
-                },
-                data
-            });
-            return response.data;
-        }
-        catch (error) {
-            const errorDetails = error.response?.data?.message || error.response?.data || error.message;
-            console.error('Azure DevOps Admin API request failed:', {
-                endpoint,
-                method,
-                status: error.response?.status,
-                statusText: error.response?.statusText,
-                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) {
-                const detail = typeof errorDetails === 'string' ? errorDetails : '';
-                throw new Error(`Azure DevOps access denied: ${detail || '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 Admin API request failed: ${error.message} - ${JSON.stringify(errorDetails)}`);
-        }
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // PIPELINE OPERATIONS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    async listPipelineDefinitions(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/build/definitions?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            pipelines: response.value.map((def) => ({
-                id: def.id,
-                name: def.name,
-                path: def.path,
-                revision: def.revision,
-                type: def.type,
-                queueStatus: def.queueStatus,
-                createdDate: def.createdDate,
-                authoredBy: def.authoredBy?.displayName,
-                repository: def.repository ? {
-                    id: def.repository.id,
-                    name: def.repository.name,
-                    type: def.repository.type
-                } : null,
-                process: def.process ? {
-                    type: def.process.type,
-                    yamlFilename: def.process.yamlFilename
-                } : null,
-                url: def._links?.web?.href
-            }))
-        };
-    }
-    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
-        };
-    }
-    async getPipelineYaml(project, definitionId) {
-        this.validateProject(project);
-        const definition = await this.getPipelineDefinition(project, definitionId);
-        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}`
-            };
-        }
-        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
-        };
-    }
-    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
-            }))
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // BUILD TROUBLESHOOTING OPERATIONS (Read-only)
-    // NOTE: These methods are duplicated in azure-devops package.
-    // If you update these, also update packages/azure-devops/src/AzureDevOpsService.ts
-    // ═══════════════════════════════════════════════════════════════════════════════
-    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;
-    }
-    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
-        };
-    }
-    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
-            }))
-        };
-    }
-    async createPipelineDefinition(project, name, repositoryId, yamlPath, folder, repositoryType = 'TfsGit', repositoryUrl, defaultBranch, serviceConnectionId) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        // Validation for external repositories
-        if (repositoryType !== 'TfsGit') {
-            if (!repositoryUrl) {
-                throw new Error(`repositoryUrl is required for ${repositoryType} repositories`);
-            }
-            if (!serviceConnectionId) {
-                throw new Error(`serviceConnectionId is required for ${repositoryType} repositories`);
-            }
-        }
-        // Normalize defaultBranch format
-        const normalizedBranch = defaultBranch
-            ? (defaultBranch.startsWith('refs/heads/') ? defaultBranch : `refs/heads/${defaultBranch}`)
-            : 'refs/heads/main';
-        // Build repository object based on type
-        let repository;
-        if (repositoryType === 'TfsGit') {
-            // Azure Repos - simple format
-            repository = {
-                id: repositoryId,
-                type: 'TfsGit'
-            };
-        }
-        else {
-            // GitHub / GitHubEnterprise - extended format
-            repository = {
-                id: repositoryId,
-                name: repositoryId, // Same as id for GitHub
-                type: repositoryType,
-                url: repositoryUrl,
-                defaultBranch: normalizedBranch,
-                properties: {
-                    connectedServiceId: serviceConnectionId
-                }
-            };
-        }
-        const definition = {
-            name,
-            path: folder || '\\',
-            type: 'build',
-            queueStatus: 'enabled',
-            process: {
-                type: 2,
-                yamlFilename: yamlPath
-            },
-            repository
-        };
-        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,
-            repositoryType,
-            url: response._links?.web?.href
-        };
-    }
-    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.');
-        }
-        const current = await this.makeRequest(`${project}/_apis/build/definitions/${definitionId}?api-version=${this.apiVersion}`);
-        const updated = {
-            ...current,
-            ...updates,
-            revision: 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
-        };
-    }
-    async renamePipelineDefinition(project, definitionId, newName) {
-        return this.updatePipelineDefinition(project, definitionId, { name: newName });
-    }
-    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
-        };
-    }
-    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'
-        };
-    }
-    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.');
-        }
-        const original = await this.makeRequest(`${project}/_apis/build/builds/${buildId}?api-version=${this.apiVersion}`);
-        return this.queueBuild(project, original.definition.id, original.sourceBranch);
-    }
-    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
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // PIPELINE APPROVAL OPERATIONS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    async listPendingApprovals(project, buildId) {
-        this.validateProject(project);
-        // Step 1: Fetch build timeline to find Checkpoint.Approval records
-        const timeline = await this.makeRequest(`${project}/_apis/build/builds/${buildId}/timeline?api-version=${this.apiVersion}`);
-        const approvalRecords = (timeline.records || []).filter((r) => r.type === 'Checkpoint.Approval');
-        if (approvalRecords.length === 0) {
-            return {
-                project,
-                buildId,
-                totalCount: 0,
-                approvals: [],
-                message: 'No approval checkpoints found for this build'
-            };
-        }
-        // Step 2: Extract approval IDs from record identifiers
-        const approvalIds = approvalRecords.map((r) => r.id);
-        // Step 3: Query the approvals API with those IDs
-        const approvalIdsParam = approvalIds.join(',');
-        const approvalsResponse = await this.makeRequest(`${project}/_apis/pipelines/approvals?approvalIds=${approvalIdsParam}&$expand=steps&api-version=${this.apiVersion}`);
-        const approvals = (approvalsResponse.value || [approvalsResponse]).map((a) => ({
-            id: a.id,
-            status: a.status,
-            createdOn: a.createdOn,
-            executionOrder: a.executionOrder,
-            minRequiredApprovers: a.minRequiredApprovers,
-            instructions: a.instructions,
-            blockedApprovers: a.blockedApprovers,
-            steps: (a.steps || []).map((s) => ({
-                assignedApprover: s.assignedApprover?.displayName,
-                assignedApproverId: s.assignedApprover?.uniqueName,
-                status: s.status,
-                comment: s.comment,
-                initiatedOn: s.initiatedOn,
-                lastModifiedOn: s.lastModifiedOn
-            }))
-        }));
-        return {
-            project,
-            buildId,
-            totalCount: approvals.length,
-            approvals
-        };
-    }
-    async approveStage(project, approvalId, status, comment) {
-        this.validateProject(project);
-        if (!this.config.enablePipelineUpsert) {
-            throw new Error('Pipeline upsert operations are disabled. Set AZUREDEVOPS_ENABLE_PIPELINE_UPSERT=true to enable.');
-        }
-        const body = [{ approvalId, status, comment: comment || '' }];
-        const response = await this.makeRequest(`${project}/_apis/pipelines/approvals?api-version=${this.apiVersion}`, 'PATCH', body, { 'Content-Type': 'application/json' });
-        const result = Array.isArray(response.value) ? response.value[0] : response;
-        return {
-            id: result.id,
-            status: result.status,
-            comment,
-            project,
-            message: `Approval ${approvalId} ${status}`
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // SERVICE CONNECTION OPERATIONS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    async listServiceConnections(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            serviceConnections: response.value.map((conn) => ({
-                id: conn.id,
-                name: conn.name,
-                type: conn.type,
-                url: conn.url,
-                description: conn.description,
-                isShared: conn.isShared,
-                isReady: conn.isReady,
-                owner: conn.owner,
-                createdBy: conn.createdBy?.displayName,
-                authorization: conn.authorization ? {
-                    scheme: conn.authorization.scheme,
-                    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
-            }))
-        };
-    }
-    async getServiceConnection(project, connectionId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            type: response.type,
-            url: response.url,
-            description: response.description,
-            isShared: response.isShared,
-            isReady: response.isReady,
-            owner: response.owner,
-            createdBy: response.createdBy?.displayName,
-            project,
-            authorization: response.authorization ? {
-                scheme: response.authorization.scheme,
-                parameters: response.authorization.parameters ?
-                    Object.keys(response.authorization.parameters).reduce((acc, key) => {
-                        acc[key] = key.toLowerCase().includes('password') ||
-                            key.toLowerCase().includes('secret') ||
-                            key.toLowerCase().includes('key') ||
-                            key.toLowerCase().includes('token')
-                            ? '***SECRET***'
-                            : response.authorization.parameters[key];
-                        return acc;
-                    }, {}) : {}
-            } : null,
-            data: response.data || {},
-            serviceEndpointProjectReferences: response.serviceEndpointProjectReferences
-        };
-    }
-    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
-                })) || []
-            }))
-        };
-    }
-    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
-        };
-    }
-    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.');
-        }
-        const current = await this.makeRequest(`${project}/_apis/serviceendpoint/endpoints/${connectionId}?api-version=${this.apiVersion}`);
-        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
-        };
-    }
-    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.');
-        }
-        const shareRequest = projectIds.map(projectId => ({
-            projectReference: { id: projectId },
-            name: ''
-        }));
-        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
-        };
-    }
-    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 OPERATIONS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    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,
-                variables: group.variables ? Object.keys(group.variables).reduce((acc, key) => {
-                    const v = group.variables[key];
-                    acc[key] = {
-                        value: v.isSecret ? '***SECRET***' : v.value,
-                        isSecret: v.isSecret || false,
-                        isReadOnly: v.isReadOnly || false
-                    };
-                    return acc;
-                }, {}) : {}
-            }))
-        };
-    }
-    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,
-            project,
-            variables: response.variables ? Object.keys(response.variables).reduce((acc, key) => {
-                const v = response.variables[key];
-                acc[key] = {
-                    value: v.isSecret ? '***SECRET***' : v.value,
-                    isSecret: v.isSecret || false,
-                    isReadOnly: v.isReadOnly || false
-                };
-                return acc;
-            }, {}) : {},
-            variableGroupProjectReferences: response.variableGroupProjectReferences
-        };
-    }
-    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(`_apis/distributedtask/variablegroups?api-version=${this.apiVersion}`, 'POST', variableGroup);
-        return {
-            id: response.id,
-            name: response.name,
-            project,
-            variableCount: Object.keys(response.variables || {}).length
-        };
-    }
-    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.');
-        }
-        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(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', updated);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            project
-        };
-    }
-    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.');
-        }
-        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
-        current.variables[variableName] = { value, isSecret };
-        const response = await this.makeRequest(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
-        return {
-            id: response.id,
-            name: response.name,
-            project,
-            variableSet: variableName,
-            isSecret
-        };
-    }
-    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.');
-        }
-        const current = await this.makeRequest(`${project}/_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`);
-        if (current.variables[variableName]) {
-            delete current.variables[variableName];
-        }
-        else {
-            throw new Error(`Variable '${variableName}' not found in group ${groupId}`);
-        }
-        const response = await this.makeRequest(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'PUT', current);
-        return {
-            id: response.id,
-            name: response.name,
-            project,
-            variableRemoved: variableName
-        };
-    }
-    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(`_apis/distributedtask/variablegroups/${groupId}?api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            groupId,
-            project,
-            deleted: true
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // AGENT POOL OPERATIONS
-    // ═══════════════════════════════════════════════════════════════════════════════
-    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
-            }))
-        };
-    }
-    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
-        };
-    }
-    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
-            }))
-        };
-    }
-    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
-        };
-    }
-    async updateAgentPool(poolId, updates) {
-        if (!this.config.enableAgentPoolUpsert) {
-            throw new Error('Agent pool upsert operations are disabled. Set AZUREDEVOPS_ENABLE_AGENT_POOL_UPSERT=true to enable.');
-        }
-        const response = await this.makeRequest(`_apis/distributedtask/pools/${poolId}?api-version=${this.apiVersion}`, 'PATCH', updates);
-        return {
-            id: response.id,
-            name: response.name,
-            autoProvision: response.autoProvision,
-            autoUpdate: response.autoUpdate,
-            autoSize: response.autoSize,
-            targetSize: response.targetSize
-        };
-    }
-    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
-        };
-    }
-    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
-    // ═══════════════════════════════════════════════════════════════════════════════
-    async listEnvironments(project) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments?api-version=${this.apiVersion}`);
-        return {
-            project,
-            totalCount: response.value.length,
-            environments: response.value.map((env) => ({
-                id: env.id,
-                name: env.name,
-                description: env.description,
-                createdBy: env.createdBy?.displayName,
-                createdOn: env.createdOn,
-                lastModifiedBy: env.lastModifiedBy?.displayName,
-                lastModifiedOn: env.lastModifiedOn
-            }))
-        };
-    }
-    async getEnvironment(project, environmentId) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}?expands=resourceReferences&api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            name: response.name,
-            description: response.description,
-            createdBy: response.createdBy?.displayName,
-            createdOn: response.createdOn,
-            lastModifiedBy: response.lastModifiedBy?.displayName,
-            lastModifiedOn: response.lastModifiedOn,
-            project,
-            resources: response.resources || []
-        };
-    }
-    async getEnvironmentDeployments(project, environmentId, top = 10) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/distributedtask/environments/${environmentId}/environmentdeploymentrecords?top=${top}&api-version=${this.apiVersion}`);
-        return {
-            project,
-            environmentId,
-            totalCount: response.value.length,
-            deployments: response.value.map((dep) => ({
-                id: dep.id,
-                environmentId: dep.environmentId,
-                definition: dep.definition ? {
-                    id: dep.definition.id,
-                    name: dep.definition.name
-                } : null,
-                owner: dep.owner?.displayName,
-                planType: dep.planType,
-                startTime: dep.startTime,
-                finishTime: dep.finishTime,
-                result: dep.result,
-                queueTime: dep.queueTime
-            }))
-        };
-    }
-    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
-        };
-    }
-    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
-        };
-    }
-    async deleteEnvironment(project, environmentId) {
-        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/distributedtask/environments/${environmentId}?api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            environmentId,
-            project,
-            deleted: true
-        };
-    }
-    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
-            }))
-        };
-    }
-    async addEnvironmentCheck(project, environmentId, checkType, configuration) {
-        this.validateProject(project);
-        if (!this.config.enableEnvironmentUpsert) {
-            throw new Error('Environment upsert operations are disabled. Set AZUREDEVOPS_ENABLE_ENVIRONMENT_UPSERT=true to enable.');
-        }
-        const 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
-        };
-    }
-    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 current = await this.makeRequest(`${project}/_apis/pipelines/checks/configurations/${checkId}?api-version=7.1-preview.1`);
-        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);
-        return {
-            id: response.id,
-            type: response.type?.name,
-            settings: response.settings,
-            timeout: response.timeout,
-            project
-        };
-    }
-    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
-        };
-    }
-    // ═══════════════════════════════════════════════════════════════════════════════
-    // CLASSIFICATION NODE OPERATIONS (Iterations & Areas)
-    // ═══════════════════════════════════════════════════════════════════════════════
-    /**
-     * Flatten classification node hierarchy into a list
-     */
-    flattenClassificationNodes(node, parentPath = '') {
-        const result = [];
-        const currentPath = parentPath ? `${parentPath}\\${node.name}` : node.name;
-        result.push({
-            id: node.id,
-            identifier: node.identifier,
-            name: node.name,
-            path: currentPath,
-            structureType: node.structureType,
-            hasChildren: node.hasChildren || false,
-            attributes: node.attributes || {},
-            url: node.url
-        });
-        if (node.children && Array.isArray(node.children)) {
-            for (const child of node.children) {
-                result.push(...this.flattenClassificationNodes(child, currentPath));
-            }
-        }
-        return result;
-    }
-    async listClassificationNodes(project, structureType, depth = 10) {
-        this.validateProject(project);
-        const response = await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}?$depth=${depth}&api-version=${this.apiVersion}`);
-        const nodes = this.flattenClassificationNodes(response);
-        return {
-            project,
-            structureType,
-            totalCount: nodes.length,
-            nodes: nodes.map((node) => ({
-                id: node.id,
-                identifier: node.identifier,
-                name: node.name,
-                path: node.path,
-                hasChildren: node.hasChildren,
-                ...(structureType === 'iterations' && node.attributes ? {
-                    startDate: node.attributes.startDate,
-                    finishDate: node.attributes.finishDate,
-                    timeFrame: node.attributes.timeFrame
-                } : {})
-            }))
-        };
-    }
-    async getClassificationNode(project, structureType, path) {
-        this.validateProject(project);
-        // Path should be URL encoded and without leading backslash
-        const cleanPath = path.replace(/^\\/, '').replace(/\\/g, '/');
-        const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
-        const response = await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}?api-version=${this.apiVersion}`);
-        return {
-            id: response.id,
-            identifier: response.identifier,
-            name: response.name,
-            structureType: response.structureType,
-            hasChildren: response.hasChildren || false,
-            path: response.path,
-            project,
-            ...(structureType === 'iterations' && response.attributes ? {
-                startDate: response.attributes.startDate,
-                finishDate: response.attributes.finishDate,
-                timeFrame: response.attributes.timeFrame
-            } : {}),
-            url: response.url
-        };
-    }
-    async createClassificationNode(project, structureType, name, parentPath, attributes) {
-        this.validateProject(project);
-        if (!this.config.enableClassificationNodeUpsert) {
-            throw new Error('Classification node upsert operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_UPSERT=true to enable.');
-        }
-        const body = { name };
-        if (structureType === 'iterations' && attributes) {
-            body.attributes = {};
-            // Azure DevOps requires ISO 8601 format with time component
-            if (attributes.startDate)
-                body.attributes.startDate = this.formatDateForAdo(attributes.startDate);
-            if (attributes.finishDate)
-                body.attributes.finishDate = this.formatDateForAdo(attributes.finishDate);
-        }
-        // Build the endpoint - if parentPath is provided, create under that path
-        let endpoint = `${project}/_apis/wit/classificationnodes/${structureType}`;
-        if (parentPath) {
-            const cleanPath = parentPath.replace(/^\\/, '').replace(/\\/g, '/');
-            const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
-            endpoint = `${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}`;
-        }
-        const response = await this.makeRequest(`${endpoint}?api-version=${this.apiVersion}`, 'POST', body);
-        return {
-            id: response.id,
-            identifier: response.identifier,
-            name: response.name,
-            path: response.path,
-            structureType,
-            project,
-            ...(structureType === 'iterations' && response.attributes ? {
-                startDate: response.attributes.startDate,
-                finishDate: response.attributes.finishDate
-            } : {}),
-            url: response.url
-        };
-    }
-    async addIterationToTeam(project, team, iterationId) {
-        this.validateProject(project);
-        if (!this.config.enableClassificationNodeUpsert) {
-            throw new Error('Classification node upsert operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_UPSERT=true to enable.');
-        }
-        const encodedTeam = encodeURIComponent(team);
-        const endpoint = `${project}/${encodedTeam}/_apis/work/teamsettings/iterations?api-version=${this.apiVersion}`;
-        const response = await this.makeRequest(endpoint, 'POST', { id: iterationId });
-        return {
-            id: response.id,
-            name: response.name,
-            path: response.path,
-            url: response.url,
-            attributes: response.attributes ? {
-                startDate: response.attributes.startDate,
-                finishDate: response.attributes.finishDate,
-                timeFrame: response.attributes.timeFrame,
-            } : undefined,
-        };
-    }
-    async updateClassificationNode(project, structureType, path, updates) {
-        this.validateProject(project);
-        if (!this.config.enableClassificationNodeUpsert) {
-            throw new Error('Classification node upsert operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_UPSERT=true to enable.');
-        }
-        const cleanPath = path.replace(/^\\/, '').replace(/\\/g, '/');
-        const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
-        const body = {};
-        if (updates.name)
-            body.name = updates.name;
-        if (structureType === 'iterations') {
-            if (updates.startDate !== undefined || updates.finishDate !== undefined) {
-                body.attributes = {};
-                // Azure DevOps requires ISO 8601 format with time component
-                if (updates.startDate !== undefined)
-                    body.attributes.startDate = this.formatDateForAdo(updates.startDate);
-                if (updates.finishDate !== undefined)
-                    body.attributes.finishDate = this.formatDateForAdo(updates.finishDate);
-            }
-        }
-        // Classification Nodes API uses regular JSON, not JSON Patch format
-        const response = await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}?api-version=${this.apiVersion}`, 'PATCH', body, undefined, 'application/json' // Override default json-patch+json content type
-        );
-        return {
-            id: response.id,
-            identifier: response.identifier,
-            name: response.name,
-            path: response.path,
-            structureType,
-            project,
-            ...(structureType === 'iterations' && response.attributes ? {
-                startDate: response.attributes.startDate,
-                finishDate: response.attributes.finishDate
-            } : {}),
-            url: response.url
-        };
-    }
-    async deleteClassificationNode(project, structureType, path, reclassifyId) {
-        this.validateProject(project);
-        if (!this.config.enableClassificationNodeDelete) {
-            throw new Error('Classification node delete operations are disabled. Set AZUREDEVOPS_ENABLE_CLASSIFICATION_NODE_DELETE=true to enable.');
-        }
-        const cleanPath = path.replace(/^\\/, '').replace(/\\/g, '/');
-        const encodedPath = encodeURIComponent(cleanPath).replace(/%2F/g, '/');
-        await this.makeRequest(`${project}/_apis/wit/classificationnodes/${structureType}/${encodedPath}?$reclassifyId=${reclassifyId}&api-version=${this.apiVersion}`, 'DELETE');
-        return {
-            path,
-            structureType,
-            project,
-            reclassifyId,
-            deleted: true
-        };
-    }
-    // ========================================
-    // ARTIFACT FEED METHODS
-    // ========================================
-    async listFeedPackages(feedName, options) {
-        this.validateFeed(feedName);
-        if (options?.project) {
-            this.validateProject(options.project);
-        }
-        const projectPrefix = options?.project ? `${options.project}/` : '';
-        const queryParams = new URLSearchParams();
-        queryParams.append('api-version', this.apiVersion);
-        if (options?.namePrefix)
-            queryParams.append('packageNameQuery', options.namePrefix);
-        if (options?.packageType)
-            queryParams.append('protocolType', options.packageType);
-        if (options?.top)
-            queryParams.append('$top', String(options.top));
-        const endpoint = `${projectPrefix}_apis/packaging/Feeds/${encodeURIComponent(feedName)}/packages?${queryParams.toString()}`;
-        const response = await this.makeRequest(endpoint, 'GET', undefined, undefined, undefined, this.feedsUrl);
-        return {
-            feed: feedName,
-            project: options?.project || '(org-scoped)',
-            totalCount: response.value.length,
-            packages: response.value.map((pkg) => ({
-                id: pkg.id,
-                name: pkg.name,
-                protocolType: pkg.protocolType,
-                latestVersion: pkg.versions?.[0]?.version,
-                publishDate: pkg.versions?.[0]?.publishDate,
-                description: pkg.description,
-            })),
-        };
-    }
-    async getPackageVersions(feedName, packageName, options) {
-        this.validateFeed(feedName);
-        if (options?.project) {
-            this.validateProject(options.project);
-        }
-        // Step 1: Resolve package name → package ID
-        const projectPrefix = options?.project ? `${options.project}/` : '';
-        const listParams = new URLSearchParams();
-        listParams.append('api-version', this.apiVersion);
-        listParams.append('packageNameQuery', packageName);
-        if (options?.packageType)
-            listParams.append('protocolType', options.packageType);
-        const listEndpoint = `${projectPrefix}_apis/packaging/Feeds/${encodeURIComponent(feedName)}/packages?${listParams.toString()}`;
-        const listResponse = await this.makeRequest(listEndpoint, 'GET', undefined, undefined, undefined, this.feedsUrl);
-        const exactMatch = listResponse.value.find((pkg) => pkg.name.toLowerCase() === packageName.toLowerCase());
-        if (!exactMatch) {
-            const available = listResponse.value.map((pkg) => pkg.name).slice(0, 10);
-            throw new Error(`Package '${packageName}' not found in feed '${feedName}'. ` +
-                (available.length > 0
-                    ? `Similar packages: ${available.join(', ')}`
-                    : 'No matching packages found.'));
-        }
-        // Step 2: Get versions for the resolved package ID
-        const versionParams = new URLSearchParams();
-        versionParams.append('api-version', this.apiVersion);
-        if (options?.top)
-            versionParams.append('$top', String(options.top));
-        if (options?.includeDelisted)
-            versionParams.append('includeDelisted', 'true');
-        const versionEndpoint = `${projectPrefix}_apis/packaging/Feeds/${encodeURIComponent(feedName)}/packages/${exactMatch.id}/versions?${versionParams.toString()}`;
-        const versionResponse = await this.makeRequest(versionEndpoint, 'GET', undefined, undefined, undefined, this.feedsUrl);
-        return {
-            feed: feedName,
-            project: options?.project || '(org-scoped)',
-            packageName: exactMatch.name,
-            packageId: exactMatch.id,
-            protocolType: exactMatch.protocolType,
-            versions: versionResponse.value.map((v) => ({
-                version: v.version,
-                publishDate: v.publishDate,
-                isLatest: v.isLatest ?? false,
-                isListed: v.isListed ?? true,
-                description: v.description,
-            })),
-        };
-    }
-}
-//# sourceMappingURL=AzureDevOpsAdminService.js.map