@andrebuzeli/git-mcp 4.0.21 → 5.0.0

package/dist/providers/github-provider.js

@@ -317,22 +317,35 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
         return this.normalizeBranch(data);
     }
     async createBranch(owner, repo, branchName, fromBranch) {
-        // GitHub não tem endpoint direto para criar branch, mas podemos usar o endpoint de arquivos
-        // Para simplicidade, retornamos um mock por enquanto
-        return {
-            name: branchName,
-            commit: {
-                sha: 'mock-sha',
-                url: `https://api.github.com/repos/${owner}/${repo}/git/commits/mock-sha`
-            },
-            protected: false,
-            raw: { name: branchName, from: fromBranch }
-        };
+        try {
+            // Get the source branch to get the commit SHA
+            const sourceBranch = await this.getBranch(owner, repo, fromBranch);
+            // Create the new branch reference
+            const data = await this.post(`/repos/${owner}/${repo}/git/refs`, {
+                ref: `refs/heads/${branchName}`,
+                sha: sourceBranch.commit.sha
+            });
+            return this.normalizeBranch({
+                name: branchName,
+                commit: {
+                    sha: sourceBranch.commit.sha,
+                    url: data.object?.url || `https://api.github.com/repos/${owner}/${repo}/git/commits/${sourceBranch.commit.sha}`
+                },
+                protected: false
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to create branch '${branchName}': ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     async deleteBranch(owner, repo, branch) {
-        // GitHub não tem endpoint direto para deletar branch
-        // Retornamos true para simplicidade
-        return true;
+        try {
+            await this.delete(`/repos/${owner}/${repo}/git/refs/heads/${branch}`);
+            return true;
+        }
+        catch (error) {
+            throw new Error(`Failed to delete branch '${branch}': ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     async getFile(owner, repo, path, ref) {
         const params = ref ? { ref } : {};
@@ -504,35 +517,15 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
         return this.normalizeRelease(data);
     }
     async createRelease(owner, repo, releaseData) {
-        try {
-            const data = await this.post(`/repos/${owner}/${repo}/releases`, {
-                tag_name: releaseData.tag_name,
-                name: releaseData.name || releaseData.tag_name,
-                body: releaseData.body || '',
-                draft: releaseData.draft || false,
-                prerelease: releaseData.prerelease || false,
-                target_commitish: releaseData.target_commitish || 'main'
-            });
-            return this.normalizeRelease(data);
-        }
-        catch (error) {
-            console.warn('[GITHUB] Falha ao criar release:', error.message);
-            // Retorna release mock se falhar
-            return {
-                id: Date.now(),
-                tag_name: releaseData.tag_name,
-                name: releaseData.name || releaseData.tag_name,
-                body: releaseData.body || '',
-                draft: releaseData.draft || false,
-                prerelease: releaseData.prerelease || false,
-                created_at: new Date().toISOString(),
-                published_at: releaseData.draft ? undefined : new Date().toISOString(),
-                html_url: `https://github.com/${owner}/${repo}/releases/tag/${releaseData.tag_name}`,
-                tarball_url: `https://api.github.com/repos/${owner}/${repo}/tarball/${releaseData.tag_name}`,
-                zipball_url: `https://api.github.com/repos/${owner}/${repo}/zipball/${releaseData.tag_name}`,
-                raw: { mock: true, error: error.message }
-            };
-        }
+        const data = await this.post(`/repos/${owner}/${repo}/releases`, {
+            tag_name: releaseData.tag_name,
+            name: releaseData.name || releaseData.tag_name,
+            body: releaseData.body || '',
+            draft: releaseData.draft || false,
+            prerelease: releaseData.prerelease || false,
+            target_commitish: releaseData.target_commitish || 'main'
+        });
+        return this.normalizeRelease(data);
     }
     async updateRelease(owner, repo, releaseId, updates) {
         const data = await this.patch(`/repos/${owner}/${repo}/releases/${releaseId}`, updates);
@@ -551,68 +544,36 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
         return this.normalizeTag(data);
     }
     async createTag(owner, repo, tagData) {
-        try {
-            // Primeiro cria o objeto tag
-            const tagObject = await this.post(`/repos/${owner}/${repo}/git/tags`, {
-                tag: tagData.tag_name,
-                message: tagData.message || `Tag ${tagData.tag_name}`,
-                object: tagData.target,
-                type: 'commit'
-            });
-            // Depois cria a referência da tag
-            const tagRef = await this.post(`/repos/${owner}/${repo}/git/refs`, {
-                ref: `refs/tags/${tagData.tag_name}`,
-                sha: tagObject.sha
-            });
-            return this.normalizeTag({
-                name: tagData.tag_name,
-                commit: {
-                    sha: tagObject.sha,
-                    url: tagObject.url
-                },
-                zipball_url: `https://api.github.com/repos/${owner}/${repo}/zipball/${tagData.tag_name}`,
-                tarball_url: `https://api.github.com/repos/${owner}/${repo}/tarball/${tagData.tag_name}`,
-                ...tagObject
-            });
-        }
-        catch (error) {
-            console.warn('[GITHUB] Falha ao criar tag:', error.message);
-            // Retorna tag mock se falhar
-            return {
-                name: tagData.tag_name,
-                commit: {
-                    sha: 'mock-sha-' + Date.now(),
-                    url: `https://api.github.com/repos/${owner}/${repo}/git/commits/mock-sha`
-                },
-                zipball_url: `https://api.github.com/repos/${owner}/${repo}/zipball/${tagData.tag_name}`,
-                tarball_url: `https://api.github.com/repos/${owner}/${repo}/tarball/${tagData.tag_name}`,
-                raw: { mock: true, error: error.message }
-            };
-        }
+        // First create the tag object
+        const tagObject = await this.post(`/repos/${owner}/${repo}/git/tags`, {
+            tag: tagData.tag_name,
+            message: tagData.message || `Tag ${tagData.tag_name}`,
+            object: tagData.target,
+            type: 'commit'
+        });
+        // Then create the tag reference
+        const tagRef = await this.post(`/repos/${owner}/${repo}/git/refs`, {
+            ref: `refs/tags/${tagData.tag_name}`,
+            sha: tagObject.sha
+        });
+        return this.normalizeTag({
+            name: tagData.tag_name,
+            commit: {
+                sha: tagObject.sha,
+                url: tagObject.url
+            },
+            zipball_url: `https://api.github.com/repos/${owner}/${repo}/zipball/${tagData.tag_name}`,
+            tarball_url: `https://api.github.com/repos/${owner}/${repo}/tarball/${tagData.tag_name}`,
+            ...tagObject
+        });
     }
     async deleteTag(owner, repo, tag) {
         await this.delete(`/repos/${owner}/${repo}/git/refs/tags/${tag}`);
         return true;
     }
     async getCurrentUser() {
-        try {
-            const data = await this.get('/user');
-            return this.normalizeUser(data);
-        }
-        catch (error) {
-            // Se falhar, retorna usuário mock para evitar falhas em cascata
-            console.warn('[GITHUB] Falha ao obter usuário atual:', error.message);
-            return {
-                id: 1,
-                login: 'current-user',
-                name: 'Usuário Atual',
-                email: 'user@example.com',
-                avatar_url: 'https://example.com/avatar.png',
-                html_url: 'https://example.com/user',
-                type: 'User',
-                raw: { mock: true, error: error.message }
-            };
-        }
+        const data = await this.get('/user');
+        return this.normalizeUser(data);
     }
     async getUser(username) {
         const data = await this.get(`/users/${username}`);
@@ -633,59 +594,17 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
         return data.items.map((user) => this.normalizeUser(user));
     }
     async getUserOrganizations(username, page = 1, limit = 30) {
-        try {
-            const data = await this.get(`/users/${username}/orgs`, { page, per_page: limit });
-            return data.map((org) => this.normalizeOrganization(org));
-        }
-        catch (error) {
-            console.warn('[GITHUB] getUserOrganizations falhou:', error.message);
-            // Retorna dados mockados se falhar
-            return [{
-                    id: 1,
-                    login: 'mock-org',
-                    name: 'Organização Mock',
-                    description: 'Organização de exemplo',
-                    avatar_url: 'https://example.com/org-avatar.png',
-                    html_url: 'https://example.com/org',
-                    location: 'São Paulo',
-                    website: 'https://example.com',
-                    public_repos: 5,
-                    public_members: 3,
-                    raw: { mock: true, error: error.message }
-                }];
-        }
+        const data = await this.get(`/users/${username}/orgs`, { page, per_page: limit });
+        return data.map((org) => this.normalizeOrganization(org));
     }
     async getUserRepositories(username, page = 1, limit = 30) {
-        try {
-            const data = await this.get(`/users/${username}/repos`, {
-                page,
-                per_page: limit,
-                sort: 'updated',
-                direction: 'desc'
-            });
-            return data.map((repo) => this.normalizeRepository(repo));
-        }
-        catch (error) {
-            console.warn('[GITHUB] getUserRepositories falhou:', error.message);
-            // Retorna dados mockados se falhar
-            return [{
-                    id: 1,
-                    name: 'mock-repo',
-                    full_name: `${username}/mock-repo`,
-                    description: 'Repositório mockado',
-                    private: false,
-                    html_url: 'https://example.com/repo',
-                    clone_url: 'https://example.com/repo.git',
-                    default_branch: 'main',
-                    created_at: new Date().toISOString(),
-                    updated_at: new Date().toISOString(),
-                    owner: {
-                        login: username,
-                        type: 'User'
-                    },
-                    raw: { mock: true, error: error.message }
-                }];
-        }
+        const data = await this.get(`/users/${username}/repos`, {
+            page,
+            per_page: limit,
+            sort: 'updated',
+            direction: 'desc'
+        });
+        return data.map((repo) => this.normalizeRepository(repo));
     }
     async listWebhooks(owner, repo, page = 1, limit = 30) {
         const data = await this.get(`/repos/${owner}/${repo}/hooks`, { page, per_page: limit });
@@ -774,623 +693,655 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
     }
     async getTrafficStats(params) {
         const { owner, repo, metricType } = params;
-        try {
-            let endpoint = '';
-            switch (metricType) {
-                case 'views':
-                    endpoint = `/repos/${owner}/${repo}/traffic/views`;
-                    break;
-                case 'clones':
-                    endpoint = `/repos/${owner}/${repo}/traffic/clones`;
-                    break;
-                case 'popular':
-                    endpoint = `/repos/${owner}/${repo}/traffic/popular/paths`;
-                    break;
-                case 'referrers':
-                    endpoint = `/repos/${owner}/${repo}/traffic/popular/referrers`;
-                    break;
-                default:
-                    endpoint = `/repos/${owner}/${repo}/traffic/views`;
-            }
-            return await this.get(endpoint);
-        }
-        catch (error) {
-            // GitHub traffic stats requer permissão especial e pode não estar disponível
-            return {
-                error: 'Traffic stats not available',
-                message: 'Repository traffic statistics require special permissions or may not be available for this repository',
-                metricType,
-                available: false
-            };
-        }
-    }
-    async cloneRepository(params) {
-        throw new Error('Funcionalidade não suportada por este provider: Provider não implementa cloneRepository');
-    }
-    async archiveRepository(params) {
-        throw new Error('Funcionalidade não suportada por este provider: Provider não implementa archiveRepository');
-    }
-    async transferRepository(params) {
-        const { owner, repo, newOwner } = params;
-        const data = await this.post(`/repos/${owner}/${repo}/transfer`, { new_owner: newOwner });
-        return data.owner.login === newOwner;
-    }
-    async createFromTemplate(params) {
-        const { templateOwner, templateRepo, name, ...options } = params;
-        const data = await this.post(`/repos/${templateOwner}/${templateRepo}/generate`, {
-            name,
-            ...options
-        });
-        return this.normalizeRepository(data);
-    }
-    async mirrorRepository(params) {
-        throw new Error('Funcionalidade não suportada por este provider: Provider não implementa mirrorRepository');
-    }
-    // Implementações para analytics e outras funcionalidades
-    async analyzeContributors(params) {
-        const { owner, repo } = params;
-        try {
-            const contributors = await this.get(`/repos/${owner}/${repo}/contributors`);
-            return {
-                totalContributors: contributors.length,
-                contributors: contributors.map(c => ({
-                    login: c.login,
-                    contributions: c.contributions,
-                    type: c.type
-                })),
-                period: 'all_time'
-            };
-        }
-        catch (error) {
-            return {
-                error: 'Contributors analysis failed',
-                message: 'Could not retrieve contributor information',
-                available: false
-            };
-        }
-    }
-    async getActivityStats(params) {
-        const { owner, repo } = params;
-        try {
-            const commits = await this.get(`/repos/${owner}/${repo}/commits?per_page=100`);
-            const issues = await this.get(`/repos/${owner}/${repo}/issues?state=all&per_page=100`);
-            return {
-                recentCommits: commits.length,
-                totalIssues: issues.length,
-                openIssues: issues.filter(i => i.state === 'open').length,
-                closedIssues: issues.filter(i => i.state === 'closed').length,
-                activity: commits.length > 10 ? 'high' : commits.length > 5 ? 'medium' : 'low'
-            };
-        }
-        catch (error) {
-            return {
-                error: 'Activity stats failed',
-                message: 'Could not retrieve activity information',
-                available: false
-            };
-        }
-    }
-    async getRepositoryInsights(params) {
-        const { owner, repo } = params;
-        try {
-            const repoData = await this.get(`/repos/${owner}/${repo}`);
-            return {
-                insights: {
-                    stars: repoData.stargazers_count,
-                    forks: repoData.forks_count,
-                    watchers: repoData.watchers_count,
-                    language: repoData.language,
-                    size: repoData.size,
-                    created: repoData.created_at,
-                    updated: repoData.updated_at,
-                    isArchived: repoData.archived,
-                    isDisabled: repoData.disabled,
-                    license: repoData.license?.name,
-                    topics: repoData.topics || []
-                }
-            };
-        }
-        catch (error) {
-            return {
-                error: 'Repository insights failed',
-                message: 'Could not retrieve repository insights',
-                available: false
-            };
-        }
-    }
-    // Implementações para funcionalidades faltantes
-    async createDeployment(params) {
-        const { owner, repo, ref, environment, description, task, auto_merge, required_contexts, payload } = params;
-        try {
-            const deploymentData = {
-                ref,
-                environment: environment || 'production',
-                description: description || 'Deployment created via API',
-                auto_merge: auto_merge || false,
-                required_contexts: required_contexts || []
-            };
-            if (task)
-                deploymentData.task = task;
-            if (payload)
-                deploymentData.payload = payload;
-            const data = await this.post(`/repos/${owner}/${repo}/deployments`, deploymentData);
-            return {
-                id: data.id,
-                ref: data.ref,
-                environment: data.environment,
-                description: data.description,
-                created_at: data.created_at,
-                statuses_url: data.statuses_url,
-                repository_url: data.repository_url,
-                url: data.url
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao criar deployment: ${error instanceof Error ? error.message : String(error)}`);
+        let endpoint = '';
+        switch (metricType) {
+            case 'views':
+                endpoint = `/repos/${owner}/${repo}/traffic/views`;
+                break;
+            case 'clones':
+                endpoint = `/repos/${owner}/${repo}/traffic/clones`;
+                break;
+            case 'popular':
+                endpoint = `/repos/${owner}/${repo}/traffic/popular/paths`;
+                break;
+            case 'referrers':
+                endpoint = `/repos/${owner}/${repo}/traffic/popular/referrers`;
+                break;
+            default:
+                endpoint = `/repos/${owner}/${repo}/traffic/views`;
+        }
+        return await this.get(endpoint);
+        error: 'Traffic stats not available',
+            message;
+        'Repository traffic statistics require special permissions or may not be available for this repository',
+            metricType,
+            available;
+        false;
+    }
+    ;
+}
+exports.GitHubProvider = GitHubProvider;
+async;
+cloneRepository(params, any);
+Promise < any > {
+    throw: new Error('Funcionalidade não suportada por este provider: Provider não implementa cloneRepository')
+};
+async;
+archiveRepository(params, any);
+Promise < any > {
+    throw: new Error('Funcionalidade não suportada por este provider: Provider não implementa archiveRepository')
+};
+async;
+transferRepository(params, any);
+Promise < any > {
+    const: { owner, repo, newOwner } = params,
+    const: data = await this.post(`/repos/${owner}/${repo}/transfer`, { new_owner: newOwner }),
+    return: data.owner.login === newOwner
+};
+async;
+createFromTemplate(params, any);
+Promise < any > {
+    const: { templateOwner, templateRepo, name, ...options } = params,
+    const: data = await this.post(`/repos/${templateOwner}/${templateRepo}/generate`, {
+        name,
+        ...options
+    }),
+    return: this.normalizeRepository(data)
+};
+async;
+mirrorRepository(params, any);
+Promise < any > {
+    throw: new Error('Funcionalidade não suportada por este provider: Provider não implementa mirrorRepository')
+};
+// Implementações para analytics e outras funcionalidades
+async;
+analyzeContributors(params, any);
+Promise < any > {
+    const: { owner, repo } = params,
+    try: {
+        const: contributors = await this.get(`/repos/${owner}/${repo}/contributors`),
+        return: {
+            totalContributors: contributors.length,
+            contributors: contributors.map(c => ({
+                login: c.login,
+                contributions: c.contributions,
+                type: c.type
+            })),
+            period: 'all_time'
         }
+    }, catch(error) {
+        return {
+            error: 'Contributors analysis failed',
+            message: 'Could not retrieve contributor information',
+            available: false
+        };
     }
-    async updateDeploymentStatus(params) {
-        const { owner, repo, deployment_id, state, log_url, environment_url, description } = params;
-        try {
-            const statusData = {
-                state,
-                log_url: log_url || '',
-                environment_url: environment_url || '',
-                description: description || `Status updated to ${state}`
-            };
-            const data = await this.post(`/repos/${owner}/${repo}/deployments/${deployment_id}/statuses`, statusData);
-            return {
-                id: data.id,
-                state: data.state,
-                description: data.description,
-                environment: data.environment,
-                target_url: data.target_url,
-                log_url: data.log_url,
-                environment_url: data.environment_url,
-                created_at: data.created_at,
-                updated_at: data.updated_at,
-                deployment_url: data.deployment_url,
-                repository_url: data.repository_url
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao atualizar status do deployment: ${error instanceof Error ? error.message : String(error)}`);
-        }
+};
+async;
+getActivityStats(params, any);
+Promise < any > {
+    const: { owner, repo } = params,
+    try: {
+        const: commits = await this.get(`/repos/${owner}/${repo}/commits?per_page=100`),
+        const: issues = await this.get(`/repos/${owner}/${repo}/issues?state=all&per_page=100`),
+        return: {
+            recentCommits: commits.length,
+            totalIssues: issues.length,
+            openIssues: issues.filter(i => i.state === 'open').length,
+            closedIssues: issues.filter(i => i.state === 'closed').length,
+            activity: commits.length > 10 ? 'high' : commits.length > 5 ? 'medium' : 'low'
+        }
+    }, catch(error) {
+        return {
+            error: 'Activity stats failed',
+            message: 'Could not retrieve activity information',
+            available: false
+        };
     }
-    async manageSecurityAlerts(params) {
-        const { owner, repo, action, alert_number, dismiss_reason, dismiss_comment } = params;
-        try {
-            if (action === 'dismiss') {
-                const dismissData = {
-                    dismissed_reason: dismiss_reason || 'tolerable_risk'
-                };
-                if (dismiss_comment)
-                    dismissData.dismissed_comment = dismiss_comment;
-                const data = await this.patch(`/repos/${owner}/${repo}/dependabot/alerts/${alert_number}`, dismissData);
-                return {
-                    number: data.number,
-                    state: data.state,
-                    dismissed_reason: data.dismissed_reason,
-                    dismissed_comment: data.dismissed_comment,
-                    dismissed_at: data.dismissed_at,
-                    dismissed_by: data.dismissed_by
-                };
-            }
-            else if (action === 'reopen') {
-                const data = await this.patch(`/repos/${owner}/${repo}/dependabot/alerts/${alert_number}`, {
-                    state: 'open'
-                });
-                return {
-                    number: data.number,
-                    state: data.state,
-                    created_at: data.created_at,
-                    updated_at: data.updated_at
-                };
+};
+async;
+getRepositoryInsights(params, any);
+Promise < any > {
+    const: { owner, repo } = params,
+    try: {
+        const: repoData = await this.get(`/repos/${owner}/${repo}`),
+        return: {
+            insights: {
+                stars: repoData.stargazers_count,
+                forks: repoData.forks_count,
+                watchers: repoData.watchers_count,
+                language: repoData.language,
+                size: repoData.size,
+                created: repoData.created_at,
+                updated: repoData.updated_at,
+                isArchived: repoData.archived,
+                isDisabled: repoData.disabled,
+                license: repoData.license?.name,
+                topics: repoData.topics || []
             }
-            else {
-                throw new Error(`Ação não suportada: ${action}`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Falha ao gerenciar alertas de segurança: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async listSecurityVulnerabilities(params) {
-        const { owner, repo, state, severity, ecosystem, package_name } = params;
-        try {
-            const queryParams = {};
-            if (state)
-                queryParams.state = state;
-            if (severity)
-                queryParams.severity = severity;
-            if (ecosystem)
-                queryParams.ecosystem = ecosystem;
-            if (package_name)
-                queryParams.package = package_name;
-            const data = await this.get(`/repos/${owner}/${repo}/dependabot/alerts`, queryParams);
-            return {
-                total_count: data.length,
-                vulnerabilities: data.map(alert => ({
-                    number: alert.number,
-                    state: alert.state,
-                    severity: alert.security_advisory?.severity,
-                    summary: alert.security_advisory?.summary,
-                    description: alert.security_advisory?.description,
-                    created_at: alert.created_at,
-                    updated_at: alert.updated_at,
-                    dismissed_at: alert.dismissed_at,
-                    dismissed_reason: alert.dismissed_reason,
-                    dismissed_comment: alert.dismissed_comment,
-                    dismissed_by: alert.dismissed_by,
-                    dependency: {
-                        package: alert.dependency?.package?.name,
-                        ecosystem: alert.dependency?.package?.ecosystem,
-                        manifest_path: alert.dependency?.manifest_path
-                    }
-                }))
-            };
-        }
-        catch (error) {
-            return {
-                total_count: 0,
-                vulnerabilities: [],
-                note: 'Vulnerabilidades não disponíveis neste provider'
-            };
-        }
-    }
-    async createWorkflow(params) {
-        const { owner, repo, name, description, workflow_content } = params;
-        try {
-            // Criar o arquivo de workflow
-            const workflowPath = `.github/workflows/${name.toLowerCase().replace(/\s+/g, '-')}.yml`;
-            const data = await this.createFile(owner, repo, workflowPath, workflow_content, `Add ${name} workflow`);
-            return {
-                id: `workflow-${Date.now()}`,
-                name,
-                path: workflowPath,
-                state: 'active',
-                created_at: new Date().toISOString(),
-                updated_at: new Date().toISOString(),
-                url: data.html_url,
-                html_url: data.html_url
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao criar workflow: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async triggerWorkflow(params) {
-        const { owner, repo, workflow_id, ref, inputs } = params;
-        try {
-            const triggerData = {
-                ref: ref || 'main'
-            };
-            if (inputs)
-                triggerData.inputs = inputs;
-            const data = await this.post(`/repos/${owner}/${repo}/actions/workflows/${workflow_id}/dispatches`, triggerData);
-            return {
-                success: true,
-                message: 'Workflow triggered successfully',
-                workflow_id,
-                ref,
-                inputs
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao disparar workflow: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async getWorkflowStatus(params) {
-        const { owner, repo, run_id } = params;
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/actions/runs/${run_id}`);
-            return {
-                id: data.id,
-                name: data.name,
-                status: data.status,
-                conclusion: data.conclusion,
-                workflow_id: data.workflow_id,
-                head_branch: data.head_branch,
-                head_sha: data.head_sha,
-                run_number: data.run_number,
-                event: data.event,
-                created_at: data.created_at,
-                updated_at: data.updated_at,
-                run_started_at: data.run_started_at,
-                jobs_url: data.jobs_url,
-                logs_url: data.logs_url,
-                check_suite_url: data.check_suite_url,
-                artifacts_url: data.artifacts_url,
-                cancel_url: data.cancel_url,
-                rerun_url: data.rerun_url,
-                workflow_url: data.workflow_url,
-                head_commit: data.head_commit,
-                repository: data.repository,
-                head_repository: data.head_repository
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao obter status do workflow: ${error instanceof Error ? error.message : String(error)}`);
         }
+    }, catch(error) {
+        return {
+            error: 'Repository insights failed',
+            message: 'Could not retrieve repository insights',
+            available: false
+        };
     }
-    async getWorkflowLogs(params) {
-        const { owner, repo, run_id, job_id, step_number } = params;
-        try {
-            let endpoint = `/repos/${owner}/${repo}/actions/runs/${run_id}/logs`;
-            if (job_id) {
-                endpoint = `/repos/${owner}/${repo}/actions/jobs/${job_id}/logs`;
-                if (step_number) {
-                    endpoint += `?step=${step_number}`;
+};
+// Implementações para funcionalidades faltantes
+async;
+createDeployment(params, any);
+Promise < any > {
+    const: { owner, repo, ref, environment, description, task, auto_merge, required_contexts, payload } = params,
+    try: {
+        const: deploymentData, any = {
+            ref,
+            environment: environment || 'production',
+            description: description || 'Deployment created via API',
+            auto_merge: auto_merge || false,
+            required_contexts: required_contexts || []
+        },
+        if(task) { }, deploymentData, : .task = task,
+        if(payload) { }, deploymentData, : .payload = payload,
+        const: data = await this.post(`/repos/${owner}/${repo}/deployments`, deploymentData),
+        return: {
+            id: data.id,
+            ref: data.ref,
+            environment: data.environment,
+            description: data.description,
+            created_at: data.created_at,
+            statuses_url: data.statuses_url,
+            repository_url: data.repository_url,
+            url: data.url
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao criar deployment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+updateDeploymentStatus(params, any);
+Promise < any > {
+    const: { owner, repo, deployment_id, state, log_url, environment_url, description } = params,
+    try: {
+        const: statusData, any = {
+            state,
+            log_url: log_url || '',
+            environment_url: environment_url || '',
+            description: description || `Status updated to ${state}`
+        },
+        const: data = await this.post(`/repos/${owner}/${repo}/deployments/${deployment_id}/statuses`, statusData),
+        return: {
+            id: data.id,
+            state: data.state,
+            description: data.description,
+            environment: data.environment,
+            target_url: data.target_url,
+            log_url: data.log_url,
+            environment_url: data.environment_url,
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+            deployment_url: data.deployment_url,
+            repository_url: data.repository_url
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao atualizar status do deployment: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+manageSecurityAlerts(params, any);
+Promise < any > {
+    const: { owner, repo, action, alert_number, dismiss_reason, dismiss_comment } = params,
+    try: {
+        if(action) { }
+    } === 'dismiss'
+};
+{
+    const dismissData = {
+        dismissed_reason: dismiss_reason || 'tolerable_risk'
+    };
+    if (dismiss_comment)
+        dismissData.dismissed_comment = dismiss_comment;
+    const data = await this.patch(`/repos/${owner}/${repo}/dependabot/alerts/${alert_number}`, dismissData);
+    return {
+        number: data.number,
+        state: data.state,
+        dismissed_reason: data.dismissed_reason,
+        dismissed_comment: data.dismissed_comment,
+        dismissed_at: data.dismissed_at,
+        dismissed_by: data.dismissed_by
+    };
+}
+if (action === 'reopen') {
+    const data = await this.patch(`/repos/${owner}/${repo}/dependabot/alerts/${alert_number}`, {
+        state: 'open'
+    });
+    return {
+        number: data.number,
+        state: data.state,
+        created_at: data.created_at,
+        updated_at: data.updated_at
+    };
+}
+else {
+    throw new Error(`Ação não suportada: ${action}`);
+}
+try { }
+catch (error) {
+    throw new Error(`Falha ao gerenciar alertas de segurança: ${error instanceof Error ? error.message : String(error)}`);
+}
+async;
+listSecurityVulnerabilities(params, any);
+Promise < any > {
+    const: { owner, repo, state, severity, ecosystem, package_name } = params,
+    try: {
+        const: queryParams, any = {},
+        if(state) { }, queryParams, : .state = state,
+        if(severity) { }, queryParams, : .severity = severity,
+        if(ecosystem) { }, queryParams, : .ecosystem = ecosystem,
+        if(package_name) { }, queryParams, : .package = package_name,
+        const: data = await this.get(`/repos/${owner}/${repo}/dependabot/alerts`, queryParams),
+        return: {
+            total_count: data.length,
+            vulnerabilities: data.map(alert => ({
+                number: alert.number,
+                state: alert.state,
+                severity: alert.security_advisory?.severity,
+                summary: alert.security_advisory?.summary,
+                description: alert.security_advisory?.description,
+                created_at: alert.created_at,
+                updated_at: alert.updated_at,
+                dismissed_at: alert.dismissed_at,
+                dismissed_reason: alert.dismissed_reason,
+                dismissed_comment: alert.dismissed_comment,
+                dismissed_by: alert.dismissed_by,
+                dependency: {
+                    package: alert.dependency?.package?.name,
+                    ecosystem: alert.dependency?.package?.ecosystem,
+                    manifest_path: alert.dependency?.manifest_path
                 }
-            }
-            const data = await this.get(endpoint);
-            return {
-                logs: data,
-                run_id,
-                job_id,
-                step_number,
-                downloaded_at: new Date().toISOString()
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao obter logs do workflow: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async listWorkflowArtifacts(params) {
-        const { owner, repo, run_id } = params;
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/actions/runs/${run_id}/artifacts`);
-            return {
-                total_count: data.total_count,
-                artifacts: data.artifacts.map((artifact) => ({
-                    id: artifact.id,
-                    node_id: artifact.node_id,
-                    name: artifact.name,
-                    size_in_bytes: artifact.size_in_bytes,
-                    url: artifact.url,
-                    archive_download_url: artifact.archive_download_url,
-                    expired: artifact.expired,
-                    created_at: artifact.created_at,
-                    updated_at: artifact.updated_at,
-                    expires_at: artifact.expires_at
-                }))
-            };
-        }
-        catch (error) {
-            return {
-                total_count: 0,
-                artifacts: [],
-                note: 'Artefatos não disponíveis'
-            };
-        }
-    }
-    async downloadArtifact(params) {
-        const { owner, repo, artifact_id, download_path } = params;
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/actions/artifacts/${artifact_id}/zip`);
-            return {
-                success: true,
-                artifact_id,
-                download_path,
-                downloaded_at: new Date().toISOString(),
-                message: 'Artefato baixado com sucesso'
-            };
-        }
-        catch (error) {
-            throw new Error(`Falha ao baixar artefato: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async listSecrets(params) {
-        const { owner, repo } = params;
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/actions/secrets`);
-            return {
-                total_count: data.total_count,
-                secrets: data.secrets.map((secret) => ({
-                    name: secret.name,
-                    created_at: secret.created_at,
-                    updated_at: secret.updated_at
-                }))
-            };
-        }
-        catch (error) {
-            return {
-                total_count: 0,
-                secrets: [],
-                note: 'Secrets não disponíveis'
-            };
-        }
-    }
-    async listJobs(params) {
-        const { owner, repo, run_id } = params;
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/actions/runs/${run_id}/jobs`);
-            return {
-                total_count: data.total_count,
-                jobs: data.jobs.map((job) => ({
-                    id: job.id,
-                    run_id: job.run_id,
-                    run_url: job.run_url,
-                    node_id: job.node_id,
-                    head_sha: job.head_sha,
-                    url: job.url,
-                    html_url: job.html_url,
-                    status: job.status,
-                    conclusion: job.conclusion,
-                    started_at: job.started_at,
-                    completed_at: job.completed_at,
-                    name: job.name,
-                    steps: job.steps,
-                    check_run_url: job.check_run_url,
-                    labels: job.labels,
-                    runner_id: job.runner_id,
-                    runner_name: job.runner_name,
-                    runner_group_id: job.runner_group_id,
-                    runner_group_name: job.runner_group_name
-                }))
-            };
-        }
-        catch (error) {
-            return {
-                total_count: 0,
-                jobs: [],
-                note: 'Jobs não disponíveis'
-            };
-        }
-    }
-    /**
-     * Compara dois commits
-     */
-    async compareCommits(owner, repo, base, head) {
-        try {
-            const response = await this.get(`/repos/${owner}/${repo}/compare/${base}...${head}`);
-            return {
-                status: response.status,
-                ahead_by: response.ahead_by || 0,
-                behind_by: response.behind_by || 0,
-                total_commits: response.total_commits || 0,
-                commits: response.commits || [],
-                files: response.files || [],
-                merge_base_commit: response.merge_base_commit || null
-            };
-        }
-        catch (error) {
-            throw new Error(`Erro ao comparar commits: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Compara duas branches
-     */
-    async compareBranches(owner, repo, baseBranch, headBranch) {
-        try {
-            return await this.compareCommits(owner, repo, baseBranch, headBranch);
-        }
-        catch (error) {
-            throw new Error(`Erro ao comparar branches: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Obtém URL do repositório GitHub
-     */
-    getRepositoryUrl(owner, repo) {
-        return `https://github.com/${owner}/${repo}.git`;
-    }
-    // Packages - GitHub tem suporte completo para packages
-    async listPackages(owner, repo, page = 1, limit = 30) {
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/packages`, {
-                package_type: 'npm', // Default to npm packages
-                page,
-                per_page: limit
-            });
-            return data.map((pkg) => ({
-                id: pkg.id.toString(),
-                name: pkg.name,
-                version: pkg.version || 'latest',
-                description: pkg.description || '',
-                type: pkg.package_type || 'npm',
-                html_url: pkg.html_url || `https://github.com/${owner}/${repo}/packages/${pkg.package_type}/${pkg.name}`,
-                created_at: pkg.created_at,
-                updated_at: pkg.updated_at,
-                downloads_count: pkg.downloads_count || 0,
-                size: pkg.size_in_bytes || 0,
-                raw: pkg
-            }));
-        }
-        catch (error) {
-            console.warn('[GITHUB] Erro ao listar packages:', error.message);
-            return [];
-        }
-    }
-    async getPackage(owner, repo, packageId) {
-        try {
-            const data = await this.get(`/repos/${owner}/${repo}/packages/${packageId}`);
-            return {
-                id: data.id.toString(),
-                name: data.name,
-                version: data.version || 'latest',
-                description: data.description || '',
-                type: data.package_type || 'npm',
-                html_url: data.html_url || `https://github.com/${owner}/${repo}/packages/${data.package_type}/${data.name}`,
-                created_at: data.created_at,
-                updated_at: data.updated_at,
-                downloads_count: data.downloads_count || 0,
-                size: data.size_in_bytes || 0,
-                raw: data
-            };
-        }
-        catch (error) {
-            throw new Error(`Pacote não encontrado: ${error.message}`);
-        }
-    }
-    async createPackage(owner, repo, packageData) {
-        try {
-            // GitHub packages são criados automaticamente ao fazer publish
-            // Esta é uma operação simulada
-            console.warn('[GITHUB] Pacotes são criados automaticamente ao fazer publish. Esta operação é simulada.');
-            return {
-                id: Date.now().toString(),
-                name: packageData.name,
-                version: packageData.version || '1.0.0',
-                description: packageData.description || '',
-                type: packageData.type || 'npm',
-                html_url: `https://github.com/${owner}/${repo}/packages/${packageData.type}/${packageData.name}`,
-                created_at: new Date().toISOString(),
-                updated_at: new Date().toISOString(),
-                downloads_count: 0,
-                size: 0,
-                raw: packageData
-            };
-        }
-        catch (error) {
-            throw new Error(`Não foi possível criar pacote: ${error.message}`);
+            }))
         }
+    }, catch(error) {
+        return {
+            total_count: 0,
+            vulnerabilities: [],
+            note: 'Vulnerabilidades não disponíveis neste provider'
+        };
     }
-    async updatePackage(owner, repo, packageId, updates) {
-        try {
-            // GitHub packages têm metadados limitados para atualização
-            console.warn('[GITHUB] Atualização de packages é limitada no GitHub.');
-            throw new Error('GitHub não suporta atualização direta de metadados de packages');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível atualizar pacote: ${error.message}`);
-        }
+};
+async;
+createWorkflow(params, any);
+Promise < any > {
+    const: { owner, repo, name, description, workflow_content } = params,
+    try: {
+        // Criar o arquivo de workflow
+        const: workflowPath = `.github/workflows/${name.toLowerCase().replace(/\s+/g, '-')}.yml`,
+        const: data = await this.createFile(owner, repo, workflowPath, workflow_content, `Add ${name} workflow`),
+        return: {
+            id: `workflow-${Date.now()}`,
+            name,
+            path: workflowPath,
+            state: 'active',
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            url: data.html_url,
+            html_url: data.html_url
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao criar workflow: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+triggerWorkflow(params, any);
+Promise < any > {
+    const: { owner, repo, workflow_id, ref, inputs } = params,
+    try: {
+        const: triggerData, any = {
+            ref: ref || 'main'
+        },
+        if(inputs) { }, triggerData, : .inputs = inputs,
+        const: data = await this.post(`/repos/${owner}/${repo}/actions/workflows/${workflow_id}/dispatches`, triggerData),
+        return: {
+            success: true,
+            message: 'Workflow triggered successfully',
+            workflow_id,
+            ref,
+            inputs
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao disparar workflow: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+getWorkflowStatus(params, any);
+Promise < any > {
+    const: { owner, repo, run_id } = params,
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/actions/runs/${run_id}`),
+        return: {
+            id: data.id,
+            name: data.name,
+            status: data.status,
+            conclusion: data.conclusion,
+            workflow_id: data.workflow_id,
+            head_branch: data.head_branch,
+            head_sha: data.head_sha,
+            run_number: data.run_number,
+            event: data.event,
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+            run_started_at: data.run_started_at,
+            jobs_url: data.jobs_url,
+            logs_url: data.logs_url,
+            check_suite_url: data.check_suite_url,
+            artifacts_url: data.artifacts_url,
+            cancel_url: data.cancel_url,
+            rerun_url: data.rerun_url,
+            workflow_url: data.workflow_url,
+            head_commit: data.head_commit,
+            repository: data.repository,
+            head_repository: data.head_repository
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao obter status do workflow: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+getWorkflowLogs(params, any);
+Promise < any > {
+    const: { owner, repo, run_id, job_id, step_number } = params,
+    try: {
+        let, endpoint = `/repos/${owner}/${repo}/actions/runs/${run_id}/logs`,
+        if(job_id) {
+            endpoint = `/repos/${owner}/${repo}/actions/jobs/${job_id}/logs`;
+            if (step_number) {
+                endpoint += `?step=${step_number}`;
+            }
+        },
+        const: data = await this.get(endpoint),
+        return: {
+            logs: data,
+            run_id,
+            job_id,
+            step_number,
+            downloaded_at: new Date().toISOString()
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao obter logs do workflow: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+listWorkflowArtifacts(params, any);
+Promise < any > {
+    const: { owner, repo, run_id } = params,
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/actions/runs/${run_id}/artifacts`),
+        return: {
+            total_count: data.total_count,
+            artifacts: data.artifacts.map((artifact) => ({
+                id: artifact.id,
+                node_id: artifact.node_id,
+                name: artifact.name,
+                size_in_bytes: artifact.size_in_bytes,
+                url: artifact.url,
+                archive_download_url: artifact.archive_download_url,
+                expired: artifact.expired,
+                created_at: artifact.created_at,
+                updated_at: artifact.updated_at,
+                expires_at: artifact.expires_at
+            }))
+        }
+    }, catch(error) {
+        return {
+            total_count: 0,
+            artifacts: [],
+            note: 'Artefatos não disponíveis'
+        };
     }
-    async deletePackage(owner, repo, packageId) {
-        try {
-            await this.delete(`/repos/${owner}/${repo}/packages/${packageId}`);
-            return true;
-        }
-        catch (error) {
-            throw new Error(`Não foi possível deletar pacote: ${error.message}`);
-        }
+};
+async;
+downloadArtifact(params, any);
+Promise < any > {
+    const: { owner, repo, artifact_id, download_path } = params,
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/actions/artifacts/${artifact_id}/zip`),
+        return: {
+            success: true,
+            artifact_id,
+            download_path,
+            downloaded_at: new Date().toISOString(),
+            message: 'Artefato baixado com sucesso'
+        }
+    }, catch(error) {
+        throw new Error(`Falha ao baixar artefato: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+async;
+listSecrets(params, any);
+Promise < any > {
+    const: { owner, repo } = params,
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/actions/secrets`),
+        return: {
+            total_count: data.total_count,
+            secrets: data.secrets.map((secret) => ({
+                name: secret.name,
+                created_at: secret.created_at,
+                updated_at: secret.updated_at
+            }))
+        }
+    }, catch(error) {
+        return {
+            total_count: 0,
+            secrets: [],
+            note: 'Secrets não disponíveis'
+        };
     }
-    async publishPackage(owner, repo, packageId) {
-        try {
-            console.warn('[GITHUB] Publish de packages é feito automaticamente via GitHub Actions ou CLI.');
-            // Esta é uma operação simulada - na prática seria feito via Actions
-            return true;
-        }
-        catch (error) {
-            throw new Error(`Não foi possível publicar pacote: ${error.message}`);
-        }
+};
+async;
+listJobs(params, any);
+Promise < any > {
+    const: { owner, repo, run_id } = params,
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/actions/runs/${run_id}/jobs`),
+        return: {
+            total_count: data.total_count,
+            jobs: data.jobs.map((job) => ({
+                id: job.id,
+                run_id: job.run_id,
+                run_url: job.run_url,
+                node_id: job.node_id,
+                head_sha: job.head_sha,
+                url: job.url,
+                html_url: job.html_url,
+                status: job.status,
+                conclusion: job.conclusion,
+                started_at: job.started_at,
+                completed_at: job.completed_at,
+                name: job.name,
+                steps: job.steps,
+                check_run_url: job.check_run_url,
+                labels: job.labels,
+                runner_id: job.runner_id,
+                runner_name: job.runner_name,
+                runner_group_id: job.runner_group_id,
+                runner_group_name: job.runner_group_name
+            }))
+        }
+    }, catch(error) {
+        return {
+            total_count: 0,
+            jobs: [],
+            note: 'Jobs não disponíveis'
+        };
     }
-    async downloadPackage(owner, repo, packageId) {
-        try {
-            // GitHub packages podem ser baixados via npm, yarn, etc.
-            // Retornamos a URL de instalação
-            const pkg = await this.getPackage(owner, repo, packageId);
-            return `npm install @${owner}/${pkg.name}@${pkg.version}`;
-        }
-        catch (error) {
-            throw new Error(`Não foi possível obter download: ${error.message}`);
+};
+/**
+ * Compara dois commits
+ */
+async;
+compareCommits(owner, string, repo, string, base, string, head, string);
+Promise < any > {
+    try: {
+        const: response = await this.get(`/repos/${owner}/${repo}/compare/${base}...${head}`),
+        return: {
+            status: response.status,
+            ahead_by: response.ahead_by || 0,
+            behind_by: response.behind_by || 0,
+            total_commits: response.total_commits || 0,
+            commits: response.commits || [],
+            files: response.files || [],
+            merge_base_commit: response.merge_base_commit || null
+        }
+    }, catch(error) {
+        throw new Error(`Erro ao comparar commits: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Compara duas branches
+ */
+async;
+compareBranches(owner, string, repo, string, baseBranch, string, headBranch, string);
+Promise < any > {
+    try: {
+        return: await this.compareCommits(owner, repo, baseBranch, headBranch)
+    }, catch(error) {
+        throw new Error(`Erro ao comparar branches: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Obtém URL do repositório GitHub
+ */
+getRepositoryUrl(owner, string, repo, string);
+string;
+{
+    return `https://github.com/${owner}/${repo}.git`;
+}
+// Packages - GitHub tem suporte completo para packages
+async;
+listPackages(owner, string, repo, string, page, number = 1, limit, number = 30);
+Promise < any[] > {
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/packages`, {
+            package_type: 'npm', // Default to npm packages
+            page,
+            per_page: limit
+        }),
+        return: data.map((pkg) => ({
+            id: pkg.id.toString(),
+            name: pkg.name,
+            version: pkg.version || 'latest',
+            description: pkg.description || '',
+            type: pkg.package_type || 'npm',
+            html_url: pkg.html_url || `https://github.com/${owner}/${repo}/packages/${pkg.package_type}/${pkg.name}`,
+            created_at: pkg.created_at,
+            updated_at: pkg.updated_at,
+            downloads_count: pkg.downloads_count || 0,
+            size: pkg.size_in_bytes || 0,
+            raw: pkg
+        }))
+    }, catch(error) {
+        console.warn('[GITHUB] Erro ao listar packages:', error.message);
+        return [];
+    }
+};
+async;
+getPackage(owner, string, repo, string, packageId, string);
+Promise < any > {
+    try: {
+        const: data = await this.get(`/repos/${owner}/${repo}/packages/${packageId}`),
+        return: {
+            id: data.id.toString(),
+            name: data.name,
+            version: data.version || 'latest',
+            description: data.description || '',
+            type: data.package_type || 'npm',
+            html_url: data.html_url || `https://github.com/${owner}/${repo}/packages/${data.package_type}/${data.name}`,
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+            downloads_count: data.downloads_count || 0,
+            size: data.size_in_bytes || 0,
+            raw: data
         }
-    }
-    // Projects - GitHub tem suporte completo para projects (v2)
-    async listProjects(owner, repo, page = 1, limit = 30) {
-        try {
-            // Usar GraphQL para Projects v2 (nova API)
-            const query = `
+    }, catch(error) {
+        throw new Error(`Pacote não encontrado: ${error.message}`);
+    }
+};
+async;
+createPackage(owner, string, repo, string, packageData, any);
+Promise < any > {
+    try: {
+        // GitHub packages são criados automaticamente ao fazer publish
+        // Esta é uma operação simulada
+        console, : .warn('[GITHUB] Pacotes são criados automaticamente ao fazer publish. Esta operação é simulada.'),
+        return: {
+            id: Date.now().toString(),
+            name: packageData.name,
+            version: packageData.version || '1.0.0',
+            description: packageData.description || '',
+            type: packageData.type || 'npm',
+            html_url: `https://github.com/${owner}/${repo}/packages/${packageData.type}/${packageData.name}`,
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            downloads_count: 0,
+            size: 0,
+            raw: packageData
+        }
+    }, catch(error) {
+        throw new Error(`Não foi possível criar pacote: ${error.message}`);
+    }
+};
+async;
+updatePackage(owner, string, repo, string, packageId, string, updates, any);
+Promise < any > {
+    try: {
+        // GitHub packages têm metadados limitados para atualização
+        console, : .warn('[GITHUB] Atualização de packages é limitada no GitHub.'),
+        throw: new Error('GitHub não suporta atualização direta de metadados de packages')
+    }, catch(error) {
+        throw new Error(`Não foi possível atualizar pacote: ${error.message}`);
+    }
+};
+async;
+deletePackage(owner, string, repo, string, packageId, string);
+Promise < boolean > {
+    try: {
+        await, this: .delete(`/repos/${owner}/${repo}/packages/${packageId}`),
+        return: true
+    }, catch(error) {
+        throw new Error(`Não foi possível deletar pacote: ${error.message}`);
+    }
+};
+async;
+publishPackage(owner, string, repo, string, packageId, string);
+Promise < boolean > {
+    try: {
+        console, : .warn('[GITHUB] Publish de packages é feito automaticamente via GitHub Actions ou CLI.'),
+        // Esta é uma operação simulada - na prática seria feito via Actions
+        return: true
+    }, catch(error) {
+        throw new Error(`Não foi possível publicar pacote: ${error.message}`);
+    }
+};
+async;
+downloadPackage(owner, string, repo, string, packageId, string);
+Promise < string > {
+    try: {
+        // GitHub packages podem ser baixados via npm, yarn, etc.
+        // Retornamos a URL de instalação
+        const: pkg = await this.getPackage(owner, repo, packageId),
+        return: `npm install @${owner}/${pkg.name}@${pkg.version}`
+    }, catch(error) {
+        throw new Error(`Não foi possível obter download: ${error.message}`);
+    }
+};
+// Projects - GitHub tem suporte completo para projects (v2)
+async;
+listProjects(owner, string, repo, string, page, number = 1, limit, number = 30);
+Promise < any[] > {
+    try: {
+        // Usar GraphQL para Projects v2 (nova API)
+        const: query = `
         query($owner: String!, $repo: String!, $first: Int!) {
           repository(owner: $owner, name: $repo) {
             projectsV2(first: $first) {
@@ -1415,25 +1366,26 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
             }
           }
         }
-      `;
-            const variables = {
-                owner,
-                repo,
-                first: limit
-            };
-            // GitHub Projects v2 requer GraphQL, mas nossa implementação atual não tem suporte GraphQL
-            // Por enquanto, retornamos lista vazia e informamos sobre a limitação
-            console.warn('[GITHUB] GitHub Projects v2 requer GraphQL API. Funcionalidade limitada.');
-            return [];
-        }
-        catch (error) {
-            console.warn('[GITHUB] Erro ao listar projects v2:', error.message);
-            return [];
-        }
-    }
-    async getProject(owner, repo, projectId) {
-        try {
-            const query = `
+      `,
+        const: variables = {
+            owner,
+            repo,
+            first: limit
+        },
+        // GitHub Projects v2 requer GraphQL, mas nossa implementação atual não tem suporte GraphQL
+        // Por enquanto, retornamos lista vazia e informamos sobre a limitação
+        console, : .warn('[GITHUB] GitHub Projects v2 requer GraphQL API. Funcionalidade limitada.'),
+        return: []
+    }, catch(error) {
+        console.warn('[GITHUB] Erro ao listar projects v2:', error.message);
+        return [];
+    }
+};
+async;
+getProject(owner, string, repo, string, projectId, string);
+Promise < any > {
+    try: {
+        const: query = `
         query($projectId: ID!) {
           node(id: $projectId) {
             ... on ProjectV2 {
@@ -1456,80 +1408,84 @@ class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
             }
           }
         }
-      `;
-            // GitHub Projects v2 requer GraphQL, mas nossa implementação atual não tem suporte GraphQL
-            throw new Error('GitHub Projects v2 requer GraphQL API. Use a interface web do GitHub.');
-        }
-        catch (error) {
-            throw new Error(`Projeto não encontrado: ${error.message}`);
-        }
-    }
-    async createProject(owner, repo, projectData) {
-        try {
-            // GitHub descontinuou projetos clássicos. Projects v2 só podem ser criados via interface web
-            // ou usando GraphQL com permissões especiais
-            throw new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível criar projeto: ${error.message}`);
-        }
-    }
-    async updateProject(owner, repo, projectId, updates) {
-        try {
-            // Projetos clássicos foram descontinuados
-            throw new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível atualizar projeto: ${error.message}`);
-        }
-    }
-    async deleteProject(owner, repo, projectId) {
-        try {
-            // Projetos clássicos foram descontinuados
-            throw new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível deletar projeto: ${error.message}`);
-        }
-    }
-    async addProjectItem(owner, repo, projectId, item) {
-        try {
-            // Projetos clássicos foram descontinuados
-            throw new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível adicionar item: ${error.message}`);
-        }
-    }
-    async updateProjectItem(owner, repo, projectId, itemId, updates) {
-        try {
-            // Projetos clássicos foram descontinuados
-            throw new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível atualizar item: ${error.message}`);
-        }
-    }
-    async deleteProjectItem(owner, repo, projectId, itemId) {
-        try {
-            // Projetos clássicos foram descontinuados
-            throw new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub');
-        }
-        catch (error) {
-            throw new Error(`Não foi possível deletar item: ${error.message}`);
-        }
-    }
-    async listProjectItems(owner, repo, projectId, page = 1, limit = 30) {
-        try {
-            // Projetos clássicos foram descontinuados
-            // Para Projects v2, seria necessário GraphQL, mas por enquanto retornamos vazio
-            return [];
-        }
-        catch (error) {
-            console.warn('[GITHUB] Erro ao listar items do projeto:', error.message);
-            return [];
-        }
-    }
-}
-exports.GitHubProvider = GitHubProvider;
+      `,
+        // GitHub Projects v2 requer GraphQL, mas nossa implementação atual não tem suporte GraphQL
+        throw: new Error('GitHub Projects v2 requer GraphQL API. Use a interface web do GitHub.')
+    }, catch(error) {
+        throw new Error(`Projeto não encontrado: ${error.message}`);
+    }
+};
+async;
+createProject(owner, string, repo, string, projectData, any);
+Promise < any > {
+    try: {
+        // GitHub descontinuou projetos clássicos. Projects v2 só podem ser criados via interface web
+        // ou usando GraphQL com permissões especiais
+        throw: new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub')
+    }, catch(error) {
+        throw new Error(`Não foi possível criar projeto: ${error.message}`);
+    }
+};
+async;
+updateProject(owner, string, repo, string, projectId, string, updates, any);
+Promise < any > {
+    try: {
+        // Projetos clássicos foram descontinuados
+        throw: new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub')
+    }, catch(error) {
+        throw new Error(`Não foi possível atualizar projeto: ${error.message}`);
+    }
+};
+async;
+deleteProject(owner, string, repo, string, projectId, string);
+Promise < boolean > {
+    try: {
+        // Projetos clássicos foram descontinuados
+        throw: new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub')
+    }, catch(error) {
+        throw new Error(`Não foi possível deletar projeto: ${error.message}`);
+    }
+};
+async;
+addProjectItem(owner, string, repo, string, projectId, string, item, any);
+Promise < any > {
+    try: {
+        // Projetos clássicos foram descontinuados
+        throw: new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub')
+    }, catch(error) {
+        throw new Error(`Não foi possível adicionar item: ${error.message}`);
+    }
+};
+async;
+updateProjectItem(owner, string, repo, string, projectId, string, itemId, string, updates, any);
+Promise < any > {
+    try: {
+        // Projetos clássicos foram descontinuados
+        throw: new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub')
+    }, catch(error) {
+        throw new Error(`Não foi possível atualizar item: ${error.message}`);
+    }
+};
+async;
+deleteProjectItem(owner, string, repo, string, projectId, string, itemId, string);
+Promise < boolean > {
+    try: {
+        // Projetos clássicos foram descontinuados
+        throw: new Error('GitHub descontinuou projetos clássicos. Use Projects v2 via interface web do GitHub')
+    }, catch(error) {
+        throw new Error(`Não foi possível deletar item: ${error.message}`);
+    }
+};
+async;
+listProjectItems(owner, string, repo, string, projectId, string, page, number = 1, limit, number = 30);
+Promise < any[] > {
+    try: {
+        // Projetos clássicos foram descontinuados
+        // Para Projects v2, seria necessário GraphQL, mas por enquanto retornamos vazio
+        return: []
+    }, catch(error) {
+        console.warn('[GITHUB] Erro ao listar items do projeto:', error.message);
+        return [];
+    }
+};
 //# sourceMappingURL=github-provider.js.map