@andrebuzeli/git-mcp 2.6.1

package/dist/tools/deployments.d.ts

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+import { VcsOperations } from '../providers/index.js';
+/**
+ * Tool: deployments
+ *
+ * DESCRIÇÃO:
+ * Gerenciamento completo de deployments com múltiplas ações
+ *
+ * FUNCIONALIDADES:
+ * - Listagem de deployments
+ * - Criação de deployment
+ * - Atualização de status de deployment
+ * - Gerenciamento de ambientes
+ * - Rollback de deployments
+ * - Monitoramento de status
+ *
+ * USO:
+ * - Para rastrear deployments em produção
+ * - Para gerenciar ambientes de deploy
+ * - Para automação de rollbacks
+ * - Para monitoramento de releases
+ *
+ * RECOMENDAÇÕES:
+ * - Use ambientes separados para staging/prod
+ * - Monitore status de deployments
+ * - Configure rollbacks automáticos
+ * - Mantenha histórico de deployments
+ */
+/**
+ * Schema de validação para entrada da tool deployments
+ */
+declare const DeploymentsInputSchema: z.ZodEffects<z.ZodObject<{
+    action: z.ZodEnum<["list", "create", "status", "environments", "rollback", "delete"]>;
+    owner: z.ZodString;
+    repo: z.ZodString;
+    provider: z.ZodOptional<z.ZodEnum<["gitea", "github", "both"]>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    deployment_id: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    task: z.ZodOptional<z.ZodString>;
+    auto_merge: z.ZodOptional<z.ZodBoolean>;
+    required_contexts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    state: z.ZodOptional<z.ZodEnum<["pending", "success", "error", "failure", "inactive", "in_progress", "queued"]>>;
+    log_url: z.ZodOptional<z.ZodString>;
+    environment_url: z.ZodOptional<z.ZodString>;
+    environment_name: z.ZodOptional<z.ZodString>;
+    wait_timer: z.ZodOptional<z.ZodNumber>;
+    reviewers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    sha: z.ZodOptional<z.ZodString>;
+    task_filter: z.ZodOptional<z.ZodString>;
+    environment_filter: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    owner: string;
+    repo: string;
+    action: "status" | "delete" | "create" | "list" | "rollback" | "environments";
+    provider?: "gitea" | "github" | "both" | undefined;
+    description?: string | undefined;
+    state?: "error" | "success" | "queued" | "in_progress" | "failure" | "pending" | "inactive" | undefined;
+    ref?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    sha?: string | undefined;
+    reviewers?: string[] | undefined;
+    deployment_id?: string | undefined;
+    environment?: string | undefined;
+    task?: string | undefined;
+    auto_merge?: boolean | undefined;
+    required_contexts?: string[] | undefined;
+    payload?: Record<string, any> | undefined;
+    log_url?: string | undefined;
+    environment_url?: string | undefined;
+    environment_name?: string | undefined;
+    wait_timer?: number | undefined;
+    task_filter?: string | undefined;
+    environment_filter?: string | undefined;
+}, {
+    owner: string;
+    repo: string;
+    action: "status" | "delete" | "create" | "list" | "rollback" | "environments";
+    provider?: "gitea" | "github" | "both" | undefined;
+    description?: string | undefined;
+    state?: "error" | "success" | "queued" | "in_progress" | "failure" | "pending" | "inactive" | undefined;
+    ref?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    sha?: string | undefined;
+    reviewers?: string[] | undefined;
+    deployment_id?: string | undefined;
+    environment?: string | undefined;
+    task?: string | undefined;
+    auto_merge?: boolean | undefined;
+    required_contexts?: string[] | undefined;
+    payload?: Record<string, any> | undefined;
+    log_url?: string | undefined;
+    environment_url?: string | undefined;
+    environment_name?: string | undefined;
+    wait_timer?: number | undefined;
+    task_filter?: string | undefined;
+    environment_filter?: string | undefined;
+}>, {
+    owner: string;
+    repo: string;
+    action: "status" | "delete" | "create" | "list" | "rollback" | "environments";
+    provider?: "gitea" | "github" | "both" | undefined;
+    description?: string | undefined;
+    state?: "error" | "success" | "queued" | "in_progress" | "failure" | "pending" | "inactive" | undefined;
+    ref?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    sha?: string | undefined;
+    reviewers?: string[] | undefined;
+    deployment_id?: string | undefined;
+    environment?: string | undefined;
+    task?: string | undefined;
+    auto_merge?: boolean | undefined;
+    required_contexts?: string[] | undefined;
+    payload?: Record<string, any> | undefined;
+    log_url?: string | undefined;
+    environment_url?: string | undefined;
+    environment_name?: string | undefined;
+    wait_timer?: number | undefined;
+    task_filter?: string | undefined;
+    environment_filter?: string | undefined;
+}, {
+    owner: string;
+    repo: string;
+    action: "status" | "delete" | "create" | "list" | "rollback" | "environments";
+    provider?: "gitea" | "github" | "both" | undefined;
+    description?: string | undefined;
+    state?: "error" | "success" | "queued" | "in_progress" | "failure" | "pending" | "inactive" | undefined;
+    ref?: string | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    sha?: string | undefined;
+    reviewers?: string[] | undefined;
+    deployment_id?: string | undefined;
+    environment?: string | undefined;
+    task?: string | undefined;
+    auto_merge?: boolean | undefined;
+    required_contexts?: string[] | undefined;
+    payload?: Record<string, any> | undefined;
+    log_url?: string | undefined;
+    environment_url?: string | undefined;
+    environment_name?: string | undefined;
+    wait_timer?: number | undefined;
+    task_filter?: string | undefined;
+    environment_filter?: string | undefined;
+}>;
+export type DeploymentsInput = z.infer<typeof DeploymentsInputSchema>;
+/**
+ * Schema de validação para resultado da tool deployments
+ */
+declare const DeploymentsResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    action: z.ZodString;
+    message: z.ZodString;
+    data: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    action: string;
+    success: boolean;
+    error?: string | undefined;
+    data?: any;
+}, {
+    message: string;
+    action: string;
+    success: boolean;
+    error?: string | undefined;
+    data?: any;
+}>;
+export type DeploymentsResult = z.infer<typeof DeploymentsResultSchema>;
+/**
+ * Implementação da tool deployments
+ */
+export declare const deploymentsTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            owner: {
+                type: string;
+                description: string;
+            };
+            repo: {
+                type: string;
+                description: string;
+            };
+            provider: {
+                type: string;
+                description: string;
+            };
+            deployment_id: {
+                type: string;
+                description: string;
+            };
+            ref: {
+                type: string;
+                description: string;
+            };
+            environment: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            task: {
+                type: string;
+                description: string;
+            };
+            auto_merge: {
+                type: string;
+                description: string;
+            };
+            required_contexts: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            payload: {
+                type: string;
+                description: string;
+            };
+            state: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            log_url: {
+                type: string;
+                description: string;
+            };
+            environment_url: {
+                type: string;
+                description: string;
+            };
+            environment_name: {
+                type: string;
+                description: string;
+            };
+            wait_timer: {
+                type: string;
+                description: string;
+            };
+            reviewers: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            sha: {
+                type: string;
+                description: string;
+            };
+            task_filter: {
+                type: string;
+                description: string;
+            };
+            environment_filter: {
+                type: string;
+                description: string;
+            };
+            page: {
+                type: string;
+                description: string;
+                minimum: number;
+            };
+            limit: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+        required: string[];
+    };
+    handler(input: DeploymentsInput): Promise<DeploymentsResult>;
+    /**
+     * Lista deployments do repositório
+     */
+    listDeployments(params: DeploymentsInput, provider: VcsOperations): Promise<DeploymentsResult>;
+    /**
+     * Cria novo deployment
+     */
+    createDeployment(params: DeploymentsInput, provider: VcsOperations): Promise<DeploymentsResult>;
+    /**
+     * Atualiza status do deployment
+     */
+    updateDeploymentStatus(params: DeploymentsInput, provider: VcsOperations): Promise<DeploymentsResult>;
+    /**
+     * Lista ambientes de deployment
+     */
+    listEnvironments(params: DeploymentsInput, provider: VcsOperations): Promise<DeploymentsResult>;
+    /**
+     * Executa rollback de deployment
+     */
+    rollbackDeployment(params: DeploymentsInput, provider: VcsOperations): Promise<DeploymentsResult>;
+    /**
+     * Remove deployment
+     */
+    deleteDeployment(params: DeploymentsInput, provider: VcsOperations): Promise<DeploymentsResult>;
+};
+export {};
+//# sourceMappingURL=deployments.d.ts.map

package/dist/tools/deployments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.d.ts","sourceRoot":"","sources":["../../src/tools/deployments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAyB,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAG7E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;GAEG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiD1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAqCL,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAqClE;;OAEG;4BAC2B,gBAAgB,YAAY,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAiCpG;;OAEG;6BAC4B,gBAAgB,YAAY,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAkCrG;;OAEG;mCACkC,gBAAgB,YAAY,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAgC3G;;OAEG;6BAC4B,gBAAgB,YAAY,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA6BrG;;OAEG;+BAC8B,gBAAgB,YAAY,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA6BvG;;OAEG;6BAC4B,gBAAgB,YAAY,aAAa,GAAG,OAAO,CAAC,iBAAiB,CAAC;CA2BtG,CAAC"}

package/dist/tools/deployments.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploymentsTool = void 0;
+const zod_1 = require("zod");
+const index_js_1 = require("../providers/index.js");
+const validator_js_1 = require("./validator.js");
+/**
+ * Tool: deployments
+ *
+ * DESCRIÇÃO:
+ * Gerenciamento completo de deployments com múltiplas ações
+ *
+ * FUNCIONALIDADES:
+ * - Listagem de deployments
+ * - Criação de deployment
+ * - Atualização de status de deployment
+ * - Gerenciamento de ambientes
+ * - Rollback de deployments
+ * - Monitoramento de status
+ *
+ * USO:
+ * - Para rastrear deployments em produção
+ * - Para gerenciar ambientes de deploy
+ * - Para automação de rollbacks
+ * - Para monitoramento de releases
+ *
+ * RECOMENDAÇÕES:
+ * - Use ambientes separados para staging/prod
+ * - Monitore status de deployments
+ * - Configure rollbacks automáticos
+ * - Mantenha histórico de deployments
+ */
+/**
+ * Schema de validação para entrada da tool deployments
+ */
+const DeploymentsInputSchema = zod_1.z.object({
+    action: zod_1.z.enum(['list', 'create', 'status', 'environments', 'rollback', 'delete']),
+    // Parâmetros comuns
+    owner: validator_js_1.CommonSchemas.owner,
+    repo: validator_js_1.CommonSchemas.repo,
+    provider: validator_js_1.CommonSchemas.provider,
+    // Parâmetros para listagem
+    page: validator_js_1.CommonSchemas.page,
+    limit: validator_js_1.CommonSchemas.limit,
+    // Parâmetros para deployment
+    deployment_id: validator_js_1.CommonSchemas.shortString,
+    ref: validator_js_1.CommonSchemas.branch,
+    environment: validator_js_1.CommonSchemas.shortString,
+    description: validator_js_1.CommonSchemas.mediumString,
+    // Parâmetros para criação
+    task: validator_js_1.CommonSchemas.shortString,
+    auto_merge: validator_js_1.CommonSchemas.boolean,
+    required_contexts: zod_1.z.array(zod_1.z.string()).optional(),
+    payload: zod_1.z.record(zod_1.z.any()).optional(),
+    // Parâmetros para status
+    state: zod_1.z.enum(['pending', 'success', 'error', 'failure', 'inactive', 'in_progress', 'queued']).optional(),
+    log_url: validator_js_1.CommonSchemas.mediumString,
+    environment_url: validator_js_1.CommonSchemas.mediumString,
+    // Parâmetros para ambientes
+    environment_name: validator_js_1.CommonSchemas.shortString,
+    wait_timer: zod_1.z.number().optional(),
+    reviewers: zod_1.z.array(zod_1.z.string()).optional(),
+    // Filtros
+    sha: validator_js_1.CommonSchemas.shortString,
+    task_filter: validator_js_1.CommonSchemas.shortString,
+    environment_filter: validator_js_1.CommonSchemas.shortString
+}).refine((data) => {
+    // Validações específicas por ação
+    if (['create'].includes(data.action)) {
+        return data.owner && data.repo && data.ref && data.environment;
+    }
+    if (['status', 'rollback', 'delete'].includes(data.action)) {
+        return data.owner && data.repo && data.deployment_id;
+    }
+    return data.owner && data.repo;
+}, {
+    message: "Parâmetros obrigatórios não fornecidos para a ação especificada"
+});
+/**
+ * Schema de validação para resultado da tool deployments
+ */
+const DeploymentsResultSchema = zod_1.z.object({
+    success: zod_1.z.boolean(),
+    action: zod_1.z.string(),
+    message: zod_1.z.string(),
+    data: zod_1.z.any().optional(),
+    error: zod_1.z.string().optional()
+});
+/**
+ * Implementação da tool deployments
+ */
+exports.deploymentsTool = {
+    name: 'deployments',
+    description: 'Manage deployments with multiple actions: list, create, status, environments, rollback, delete. Suporte completo a GitHub e Gitea simultaneamente. Boas práticas: use ambientes separados para staging/prod, monitore status de deployments, configure rollbacks automáticos e mantenha histórico de deployments.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['list', 'create', 'status', 'environments', 'rollback', 'delete'],
+                description: 'Action to perform on deployments'
+            },
+            owner: { type: 'string', description: 'Repository owner' },
+            repo: { type: 'string', description: 'Repository name' },
+            provider: { type: 'string', description: 'Specific provider (github, gitea) or use default' },
+            deployment_id: { type: 'string', description: 'Deployment ID' },
+            ref: { type: 'string', description: 'Git reference to deploy' },
+            environment: { type: 'string', description: 'Deployment environment' },
+            description: { type: 'string', description: 'Deployment description' },
+            task: { type: 'string', description: 'Deployment task' },
+            auto_merge: { type: 'boolean', description: 'Auto merge deployment' },
+            required_contexts: { type: 'array', items: { type: 'string' }, description: 'Required status contexts' },
+            payload: { type: 'object', description: 'Deployment payload' },
+            state: { type: 'string', enum: ['pending', 'success', 'error', 'failure', 'inactive', 'in_progress', 'queued'], description: 'Deployment state' },
+            log_url: { type: 'string', description: 'Log URL' },
+            environment_url: { type: 'string', description: 'Environment URL' },
+            environment_name: { type: 'string', description: 'Environment name' },
+            wait_timer: { type: 'number', description: 'Wait timer in minutes' },
+            reviewers: { type: 'array', items: { type: 'string' }, description: 'Environment reviewers' },
+            sha: { type: 'string', description: 'Commit SHA filter' },
+            task_filter: { type: 'string', description: 'Task filter' },
+            environment_filter: { type: 'string', description: 'Environment filter' },
+            page: { type: 'number', description: 'Page number', minimum: 1 },
+            limit: { type: 'number', description: 'Items per page', minimum: 1, maximum: 100 }
+        },
+        required: ['action']
+    },
+    async handler(input) {
+        try {
+            const validatedInput = DeploymentsInputSchema.parse(input);
+            const provider = validatedInput.provider
+                ? index_js_1.globalProviderFactory.getProvider(validatedInput.provider)
+                : index_js_1.globalProviderFactory.getDefaultProvider();
+            if (!provider) {
+                throw new Error(`Provider '${validatedInput.provider}' não encontrado`);
+            }
+            switch (validatedInput.action) {
+                case 'list':
+                    return await this.listDeployments(validatedInput, provider);
+                case 'create':
+                    return await this.createDeployment(validatedInput, provider);
+                case 'status':
+                    return await this.updateDeploymentStatus(validatedInput, provider);
+                case 'environments':
+                    return await this.listEnvironments(validatedInput, provider);
+                case 'rollback':
+                    return await this.rollbackDeployment(validatedInput, provider);
+                case 'delete':
+                    return await this.deleteDeployment(validatedInput, provider);
+                default:
+                    throw new Error(`Ação não suportada: ${validatedInput.action}`);
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                action: input.action || 'unknown',
+                message: 'Erro na operação de deployments',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    },
+    /**
+     * Lista deployments do repositório
+     */
+    async listDeployments(params, provider) {
+        try {
+            if (!provider.listDeployments) {
+                return {
+                    success: false,
+                    action: 'list-deployments',
+                    message: 'Funcionalidade não suportada por este provider',
+                    error: 'Provider não implementa listDeployments'
+                };
+            }
+            const result = await provider.listDeployments({
+                owner: params.owner,
+                repo: params.repo,
+                sha: params.sha,
+                ref: params.ref,
+                task: params.task_filter,
+                environment: params.environment_filter,
+                page: params.page,
+                limit: params.limit
+            });
+            return {
+                success: true,
+                action: 'list',
+                message: `${result.deployments?.length || 0} deployments encontrados`,
+                data: result
+            };
+        }
+        catch (error) {
+            throw new Error(`Falha ao listar deployments: ${error}`);
+        }
+    },
+    /**
+     * Cria novo deployment
+     */
+    async createDeployment(params, provider) {
+        try {
+            if (!provider.createDeployment) {
+                return {
+                    success: false,
+                    action: 'create-deployment',
+                    message: 'Funcionalidade não suportada por este provider',
+                    error: 'Provider não implementa createDeployment'
+                };
+            }
+            const result = await provider.createDeployment({
+                owner: params.owner,
+                repo: params.repo,
+                ref: params.ref,
+                environment: params.environment,
+                description: params.description,
+                task: params.task || 'deploy',
+                auto_merge: params.auto_merge,
+                required_contexts: params.required_contexts,
+                payload: params.payload
+            });
+            return {
+                success: true,
+                action: 'create',
+                message: `Deployment criado com sucesso`,
+                data: result
+            };
+        }
+        catch (error) {
+            throw new Error(`Falha ao criar deployment: ${error}`);
+        }
+    },
+    /**
+     * Atualiza status do deployment
+     */
+    async updateDeploymentStatus(params, provider) {
+        try {
+            if (!provider.updateDeploymentStatus) {
+                return {
+                    success: false,
+                    action: 'update-deployment-status',
+                    message: 'Funcionalidade não suportada por este provider',
+                    error: 'Provider não implementa updateDeploymentStatus'
+                };
+            }
+            const result = await provider.updateDeploymentStatus({
+                owner: params.owner,
+                repo: params.repo,
+                deployment_id: params.deployment_id,
+                state: params.state || 'pending',
+                log_url: params.log_url,
+                description: params.description,
+                environment_url: params.environment_url
+            });
+            return {
+                success: true,
+                action: 'status',
+                message: `Status do deployment atualizado com sucesso`,
+                data: result
+            };
+        }
+        catch (error) {
+            throw new Error(`Falha ao atualizar status do deployment: ${error}`);
+        }
+    },
+    /**
+     * Lista ambientes de deployment
+     */
+    async listEnvironments(params, provider) {
+        try {
+            if (!provider.listEnvironments) {
+                return {
+                    success: false,
+                    action: 'list-environments',
+                    message: 'Funcionalidade não suportada por este provider',
+                    error: 'Provider não implementa listEnvironments'
+                };
+            }
+            const result = await provider.listEnvironments({
+                owner: params.owner,
+                repo: params.repo,
+                page: params.page,
+                limit: params.limit
+            });
+            return {
+                success: true,
+                action: 'environments',
+                message: `${result.environments?.length || 0} ambientes encontrados`,
+                data: result
+            };
+        }
+        catch (error) {
+            throw new Error(`Falha ao listar ambientes: ${error}`);
+        }
+    },
+    /**
+     * Executa rollback de deployment
+     */
+    async rollbackDeployment(params, provider) {
+        try {
+            if (!provider.rollbackDeployment) {
+                return {
+                    success: false,
+                    action: 'rollback-deployment',
+                    message: 'Funcionalidade não suportada por este provider',
+                    error: 'Provider não implementa rollbackDeployment'
+                };
+            }
+            const result = await provider.rollbackDeployment({
+                owner: params.owner,
+                repo: params.repo,
+                deployment_id: params.deployment_id,
+                description: params.description || 'Rollback automático'
+            });
+            return {
+                success: true,
+                action: 'rollback',
+                message: `Rollback do deployment executado com sucesso`,
+                data: result
+            };
+        }
+        catch (error) {
+            throw new Error(`Falha ao executar rollback: ${error}`);
+        }
+    },
+    /**
+     * Remove deployment
+     */
+    async deleteDeployment(params, provider) {
+        try {
+            if (!provider.deleteDeployment) {
+                return {
+                    success: false,
+                    action: 'delete-deployment',
+                    message: 'Funcionalidade não suportada por este provider',
+                    error: 'Provider não implementa deleteDeployment'
+                };
+            }
+            const result = await provider.deleteDeployment({
+                owner: params.owner,
+                repo: params.repo,
+                deployment_id: params.deployment_id
+            });
+            return {
+                success: true,
+                action: 'delete',
+                message: `Deployment removido com sucesso`,
+                data: result
+            };
+        }
+        catch (error) {
+            throw new Error(`Falha ao remover deployment: ${error}`);
+        }
+    }
+};
+//# sourceMappingURL=deployments.js.map