@andrebuzeli/git-mcp 5.0.5 → 5.0.6

package/dist/providers/github-provider.js

@@ -1,307 +1,670 @@
 "use strict";
+/**
+ * GitHub Provider
+ *
+ * Implementation of BaseProvider for GitHub API operations.
+ * Handles authentication, repository management, issues, PRs, and more.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubProvider = void 0;
+const rest_1 = require("@octokit/rest");
 const base_provider_js_1 = require("./base-provider.js");
-/**
- * Provider para GitHub API
- */
-class GitHubProvider extends base_provider_js_1.BaseVcsProvider {
+const retry_js_1 = require("../utils/retry.js");
+class GitHubProvider extends base_provider_js_1.BaseProvider {
+    octokit = null;
+    githubConfig;
     constructor(config) {
-        super(config);
-    }
-    getBaseUrl(config) {
-        return 'https://api.github.com';
-    }
-    getHeaders(config) {
-        return {
-            'Authorization': `Bearer ${config.token}`,
-            'Accept': 'application/vnd.github.v3+json',
-            'User-Agent': 'Git-MCP-Server/5.0.2'
-        };
-    }
-    // Implementação básica dos métodos essenciais
-    async createRepository(params) {
-        const { name, description, private: isPrivate } = params;
-        const response = await this.client.post('/user/repos', {
-            name,
-            description: description || '',
-            private: isPrivate || false,
-            auto_init: true
-        });
-        return this.normalizeRepository(response.data);
-    }
-    async listRepositories(username, page = 1, limit = 30) {
-        const url = username ? `/users/${username}/repos` : '/user/repos';
-        const response = await this.client.get(url, {
-            params: { page, per_page: limit }
-        });
-        return response.data.map((repo) => this.normalizeRepository(repo));
-    }
-    async getRepository(owner, repo) {
-        const response = await this.client.get(`/repos/${owner}/${repo}`);
-        return this.normalizeRepository(response.data);
+        super('github', config);
+        this.githubConfig = config;
+        if (this.isConfigured()) {
+            this.octokit = new rest_1.Octokit({
+                auth: this.githubConfig.token,
+                userAgent: 'git-mcp/1.0.0'
+            });
+        }
     }
-    async updateRepository(owner, repo, updates) {
-        const response = await this.client.patch(`/repos/${owner}/${repo}`, updates);
-        return this.normalizeRepository(response.data);
+    /**
+     * Check if GitHub provider is properly configured
+     */
+    isConfigured() {
+        return !!(this.githubConfig.token && this.githubConfig.username);
     }
-    async deleteRepository(owner, repo) {
+    /**
+     * Validate GitHub credentials by making a test API call
+     */
+    async validateCredentials() {
+        if (!this.isConfigured() || !this.octokit) {
+            return false;
+        }
         try {
-            await this.client.delete(`/repos/${owner}/${repo}`);
+            await this.octokit.rest.users.getAuthenticated();
             return true;
         }
         catch (error) {
             return false;
         }
     }
-    async forkRepository(owner, repo, organization) {
-        const response = await this.client.post(`/repos/${owner}/${repo}/forks`, organization ? { organization } : {});
-        return this.normalizeRepository(response.data);
-    }
-    async searchRepositories(query, page = 1, limit = 30) {
-        const response = await this.client.get('/search/repositories', {
-            params: {
-                q: query,
-                page,
-                per_page: limit
-            }
-        });
-        return response.data.items.map((repo) => this.normalizeRepository(repo));
-    }
-    // Métodos auxiliares e normalizadores
-    // Implementação dos métodos abstratos obrigatórios
-    normalizeRepository(data) {
-        return {
-            id: data.id,
-            name: data.name,
-            full_name: data.full_name,
-            description: data.description || '',
-            private: data.private,
-            html_url: data.html_url,
-            clone_url: data.clone_url,
-            default_branch: data.default_branch || 'main',
-            created_at: data.created_at,
-            updated_at: data.updated_at,
-            owner: {
-                login: data.owner.login,
-                type: data.owner.type
-            },
-            raw: data
-        };
-    }
-    normalizeBranch(data) {
-        return {
-            name: data.name,
-            commit: {
-                sha: data.commit.sha,
-                url: data.commit.url
-            },
-            protected: data.protected || false,
-            raw: data
-        };
+    /**
+     * Execute a GitHub operation
+     */
+    async executeOperation(operation, params) {
+        if (!this.isConfigured()) {
+            return this.formatError('GITHUB_NOT_CONFIGURED', 'GitHub provider is not configured. Please set GITHUB_TOKEN and GITHUB_USERNAME environment variables.', { missingFields: this.getMissingConfigFields() });
+        }
+        if (!this.octokit) {
+            return this.formatError('GITHUB_CLIENT_ERROR', 'GitHub client is not initialized');
+        }
+        if (!this.isOperationSupported(operation)) {
+            return this.formatError('UNSUPPORTED_OPERATION', `Operation '${operation}' is not supported by GitHub provider`, { supportedOperations: this.getSupportedOperations() });
+        }
+        try {
+            const result = await (0, retry_js_1.retry)(() => this.executeGitHubOperation(operation, params), {
+                retries: 3,
+                factor: 2,
+                minTimeout: 200,
+                maxTimeout: 2000,
+                retryOn: (err) => {
+                    // Retry on network errors and 5xx responses
+                    if (!err)
+                        return false;
+                    const status = err.status || err.statusCode || (err.response && err.response.status);
+                    if (!status)
+                        return true; // network or unknown error
+                    return status >= 500 || status === 429;
+                }
+            });
+            return this.formatSuccess(result);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return this.formatError('GITHUB_API_ERROR', `GitHub API error: ${errorMessage}`, error);
+        }
     }
-    normalizeFile(data) {
-        return {
-            name: data.name,
-            path: data.path,
-            sha: data.sha,
-            size: data.size,
-            url: data.url,
-            html_url: data.html_url,
-            git_url: data.git_url,
-            download_url: data.download_url,
-            type: data.type,
-            content: data.content,
-            encoding: data.encoding,
-            raw: data
-        };
+    /**
+     * Get supported operations for GitHub provider
+     */
+    getSupportedOperations() {
+        return [
+            // Repository operations
+            'repo-create', 'repo-list', 'repo-get', 'repo-update', 'repo-delete', 'repo-fork', 'repo-search',
+            // Issue operations
+            'issue-create', 'issue-list', 'issue-get', 'issue-update', 'issue-close', 'issue-comment', 'issue-search',
+            // Pull request operations
+            'pr-create', 'pr-list', 'pr-get', 'pr-update', 'pr-merge', 'pr-close', 'pr-review', 'pr-search',
+            // Branch operations
+            'branch-create', 'branch-list', 'branch-get', 'branch-delete', 'branch-compare',
+            // Tag operations
+            'tag-create', 'tag-list', 'tag-get', 'tag-delete', 'tag-search',
+            // Release operations
+            'release-create', 'release-list', 'release-get', 'release-update', 'release-delete', 'release-publish', 'release-download',
+            // File operations
+            'file-read', 'file-create', 'file-update', 'file-delete', 'file-search',
+            // Backwards/IDE compatibility aliases used by some MCP clients
+            'listFiles', 'getFile',
+            // Package operations
+            'package-list', 'package-get', 'package-create', 'package-update', 'package-delete', 'package-publish', 'package-download'
+        ];
     }
-    normalizeCommit(data) {
-        return {
-            sha: data.sha,
-            url: data.url,
-            html_url: data.html_url,
-            author: data.commit.author,
-            committer: data.commit.committer,
-            message: data.commit.message,
-            tree: data.commit.tree,
-            parents: data.parents,
-            raw: data
-        };
+    /**
+     * Get missing configuration fields
+     */
+    getMissingConfigFields() {
+        const missing = [];
+        if (!this.githubConfig.token) {
+            missing.push('GITHUB_TOKEN');
+        }
+        if (!this.githubConfig.username) {
+            missing.push('GITHUB_USERNAME');
+        }
+        return missing;
     }
-    normalizeIssue(data) {
-        return {
-            id: data.id,
-            number: data.number,
-            title: data.title,
-            body: data.body || '',
-            state: data.state,
-            created_at: data.created_at,
-            updated_at: data.updated_at,
-            closed_at: data.closed_at,
-            user: {
-                login: data.user.login,
-                id: data.user.id
-            },
-            assignees: data.assignees?.map((a) => ({ login: a.login, id: a.id })) || [],
-            labels: data.labels?.map((l) => ({ name: l.name, color: l.color })) || [],
-            raw: data
-        };
+    /**
+     * Execute specific GitHub operations
+     */
+    async executeGitHubOperation(operation, params) {
+        if (!this.octokit) {
+            throw new Error('GitHub client not initialized');
+        }
+        // Repository operations
+        if (operation.startsWith('repo-')) {
+            return this.executeRepositoryOperation(operation, params);
+        }
+        // Issue operations
+        if (operation.startsWith('issue-')) {
+            return this.executeIssueOperation(operation, params);
+        }
+        // Pull request operations
+        if (operation.startsWith('pr-')) {
+            return this.executePullRequestOperation(operation, params);
+        }
+        // Branch operations
+        if (operation.startsWith('branch-')) {
+            return this.executeBranchOperation(operation, params);
+        }
+        // Tag operations
+        if (operation.startsWith('tag-')) {
+            return this.executeTagOperation(operation, params);
+        }
+        // Release operations
+        if (operation.startsWith('release-')) {
+            return this.executeReleaseOperation(operation, params);
+        }
+        // File operations
+        if (operation.startsWith('file-')) {
+            return this.executeFileOperation(operation, params);
+        }
+        // Package operations
+        if (operation.startsWith('package-')) {
+            return this.executePackageOperation(operation, params);
+        }
+        throw new Error(`Unsupported operation: ${operation}`);
     }
-    normalizePullRequest(data) {
-        return {
-            id: data.id,
-            number: data.number,
-            title: data.title,
-            body: data.body || '',
-            state: data.state,
-            created_at: data.created_at,
-            updated_at: data.updated_at,
-            closed_at: data.closed_at,
-            merged_at: data.merged_at,
-            user: {
-                login: data.user.login,
-                id: data.user.id
-            },
-            head: {
-                ref: data.head.ref,
-                sha: data.head.sha,
-                repo: {
-                    name: data.head.repo?.name || '',
-                    full_name: data.head.repo?.full_name || ''
-                }
-            },
-            base: {
-                ref: data.base.ref,
-                sha: data.base.sha,
-                repo: {
-                    name: data.base.repo.name,
-                    full_name: data.base.repo.full_name
-                }
-            },
-            mergeable: data.mergeable,
-            raw: data
-        };
+    /**
+     * Execute repository operations
+     */
+    async executeRepositoryOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, ...otherParams } = params;
+        switch (operation) {
+            case 'repo-create':
+                return this.octokit.rest.repos.createForAuthenticatedUser({
+                    name: params.name,
+                    description: params.description,
+                    private: params.private || false,
+                    ...otherParams
+                });
+            case 'repo-list':
+                return this.octokit.rest.repos.listForUser({
+                    username: owner,
+                    type: params.type || 'all',
+                    ...otherParams
+                });
+            case 'repo-get':
+                return this.octokit.rest.repos.get({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            case 'repo-update':
+                return this.octokit.rest.repos.update({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            case 'repo-delete':
+                return this.octokit.rest.repos.delete({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            case 'repo-fork':
+                return this.octokit.rest.repos.createFork({
+                    owner,
+                    repo,
+                    organization: params.organization,
+                    ...otherParams
+                });
+            case 'repo-search':
+                return this.octokit.rest.search.repos({
+                    q: params.query,
+                    sort: params.sort,
+                    order: params.order,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported repository operation: ${operation}`);
+        }
     }
-    normalizeRelease(data) {
-        return {
-            id: data.id,
-            tag_name: data.tag_name,
-            name: data.name || data.tag_name,
-            body: data.body || '',
-            draft: data.draft,
-            prerelease: data.prerelease,
-            created_at: data.created_at,
-            published_at: data.published_at,
-            html_url: data.html_url,
-            tarball_url: data.tarball_url,
-            zipball_url: data.zipball_url,
-            raw: data
-        };
+    /**
+     * Execute issue operations
+     */
+    async executeIssueOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, issue_number, ...otherParams } = params;
+        switch (operation) {
+            case 'issue-create':
+                return this.octokit.rest.issues.create({
+                    owner,
+                    repo,
+                    title: params.title,
+                    body: params.body,
+                    labels: params.labels,
+                    ...otherParams
+                });
+            case 'issue-list':
+                return this.octokit.rest.issues.listForRepo({
+                    owner,
+                    repo,
+                    state: params.state || 'open',
+                    ...otherParams
+                });
+            case 'issue-get':
+                return this.octokit.rest.issues.get({
+                    owner,
+                    repo,
+                    issue_number,
+                    ...otherParams
+                });
+            case 'issue-update':
+                return this.octokit.rest.issues.update({
+                    owner,
+                    repo,
+                    issue_number,
+                    ...otherParams
+                });
+            case 'issue-close':
+                return this.octokit.rest.issues.update({
+                    owner,
+                    repo,
+                    issue_number,
+                    state: 'closed',
+                    ...otherParams
+                });
+            case 'issue-comment':
+                return this.octokit.rest.issues.createComment({
+                    owner,
+                    repo,
+                    issue_number,
+                    body: params.body,
+                    ...otherParams
+                });
+            case 'issue-search':
+                return this.octokit.rest.search.issuesAndPullRequests({
+                    q: `${params.query} type:issue`,
+                    sort: params.sort,
+                    order: params.order,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported issue operation: ${operation}`);
+        }
     }
-    normalizeTag(data) {
-        return {
-            name: data.name,
-            commit: {
-                sha: data.commit.sha,
-                url: data.commit.url
-            },
-            zipball_url: data.zipball_url,
-            tarball_url: data.tarball_url,
-            raw: data
-        };
+    /**
+     * Execute pull request operations
+     */
+    async executePullRequestOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, pull_number, ...otherParams } = params;
+        switch (operation) {
+            case 'pr-create':
+                return this.octokit.rest.pulls.create({
+                    owner,
+                    repo,
+                    title: params.title,
+                    head: params.head,
+                    base: params.base,
+                    body: params.body,
+                    ...otherParams
+                });
+            case 'pr-list':
+                return this.octokit.rest.pulls.list({
+                    owner,
+                    repo,
+                    state: params.state || 'open',
+                    ...otherParams
+                });
+            case 'pr-get':
+                return this.octokit.rest.pulls.get({
+                    owner,
+                    repo,
+                    pull_number,
+                    ...otherParams
+                });
+            case 'pr-update':
+                return this.octokit.rest.pulls.update({
+                    owner,
+                    repo,
+                    pull_number,
+                    ...otherParams
+                });
+            case 'pr-merge':
+                return this.octokit.rest.pulls.merge({
+                    owner,
+                    repo,
+                    pull_number,
+                    commit_title: params.commit_title,
+                    commit_message: params.commit_message,
+                    merge_method: params.merge_method || 'merge',
+                    ...otherParams
+                });
+            case 'pr-close':
+                return this.octokit.rest.pulls.update({
+                    owner,
+                    repo,
+                    pull_number,
+                    state: 'closed',
+                    ...otherParams
+                });
+            case 'pr-review':
+                return this.octokit.rest.pulls.createReview({
+                    owner,
+                    repo,
+                    pull_number,
+                    event: params.event,
+                    body: params.body,
+                    ...otherParams
+                });
+            case 'pr-search':
+                return this.octokit.rest.search.issuesAndPullRequests({
+                    q: `${params.query} type:pr`,
+                    sort: params.sort,
+                    order: params.order,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported pull request operation: ${operation}`);
+        }
     }
-    normalizeUser(data) {
-        return {
-            id: data.id,
-            login: data.login,
-            name: data.name,
-            email: data.email,
-            avatar_url: data.avatar_url,
-            html_url: data.html_url,
-            type: data.type,
-            site_admin: data.site_admin,
-            raw: data
-        };
+    /**
+     * Execute branch operations
+     */
+    async executeBranchOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, ...otherParams } = params;
+        switch (operation) {
+            case 'branch-create':
+                return this.octokit.rest.git.createRef({
+                    owner,
+                    repo,
+                    ref: `refs/heads/${params.branch}`,
+                    sha: params.sha,
+                    ...otherParams
+                });
+            case 'branch-list':
+                return this.octokit.rest.repos.listBranches({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            case 'branch-get':
+                return this.octokit.rest.repos.getBranch({
+                    owner,
+                    repo,
+                    branch: params.branch,
+                    ...otherParams
+                });
+            case 'branch-delete':
+                return this.octokit.rest.git.deleteRef({
+                    owner,
+                    repo,
+                    ref: `heads/${params.branch}`,
+                    ...otherParams
+                });
+            case 'branch-compare':
+                return this.octokit.rest.repos.compareCommits({
+                    owner,
+                    repo,
+                    base: params.base,
+                    head: params.head,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported branch operation: ${operation}`);
+        }
     }
-    normalizeWebhook(data) {
-        return {
-            id: data.id,
-            name: data.name,
-            active: data.active,
-            events: data.events,
-            config: data.config,
-            created_at: data.created_at,
-            updated_at: data.updated_at,
-            raw: data
-        };
+    /**
+     * Execute tag operations
+     */
+    async executeTagOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, ...otherParams } = params;
+        switch (operation) {
+            case 'tag-create':
+                return this.octokit.rest.git.createTag({
+                    owner,
+                    repo,
+                    tag: params.tag,
+                    message: params.message,
+                    object: params.object,
+                    type: params.type || 'commit',
+                    ...otherParams
+                });
+            case 'tag-list':
+                return this.octokit.rest.repos.listTags({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            case 'tag-get':
+                return this.octokit.rest.git.getTag({
+                    owner,
+                    repo,
+                    tag_sha: params.tag_sha,
+                    ...otherParams
+                });
+            case 'tag-delete':
+                return this.octokit.rest.git.deleteRef({
+                    owner,
+                    repo,
+                    ref: `tags/${params.tag}`,
+                    ...otherParams
+                });
+            case 'tag-search':
+                return this.octokit.rest.repos.listTags({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported tag operation: ${operation}`);
+        }
     }
-    // Implementação do método uploadProject
-    async uploadProject(owner, repo, projectPath, message, branch) {
-        // Implementação básica - pode ser expandida conforme necessário
-        throw new Error('uploadProject not implemented for GitHub provider');
+    /**
+     * Execute release operations
+     */
+    async executeReleaseOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, release_id, ...otherParams } = params;
+        switch (operation) {
+            case 'release-create':
+                return this.octokit.rest.repos.createRelease({
+                    owner,
+                    repo,
+                    tag_name: params.tag_name,
+                    name: params.name,
+                    body: params.body,
+                    draft: params.draft || false,
+                    prerelease: params.prerelease || false,
+                    ...otherParams
+                });
+            case 'release-list':
+                return this.octokit.rest.repos.listReleases({
+                    owner,
+                    repo,
+                    ...otherParams
+                });
+            case 'release-get':
+                return this.octokit.rest.repos.getRelease({
+                    owner,
+                    repo,
+                    release_id,
+                    ...otherParams
+                });
+            case 'release-update':
+                return this.octokit.rest.repos.updateRelease({
+                    owner,
+                    repo,
+                    release_id,
+                    ...otherParams
+                });
+            case 'release-delete':
+                return this.octokit.rest.repos.deleteRelease({
+                    owner,
+                    repo,
+                    release_id,
+                    ...otherParams
+                });
+            case 'release-publish':
+                return this.octokit.rest.repos.updateRelease({
+                    owner,
+                    repo,
+                    release_id,
+                    draft: false,
+                    ...otherParams
+                });
+            case 'release-download':
+                return this.octokit.rest.repos.getReleaseAsset({
+                    owner,
+                    repo,
+                    asset_id: params.asset_id,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported release operation: ${operation}`);
+        }
     }
-    getRepositoryUrl(owner, repo) {
-        return `https://github.com/${owner}/${repo}.git`;
+    /**
+     * Execute file operations
+     */
+    async executeFileOperation(operation, params) {
+        const { owner = this.githubConfig.username, repo, path, ...otherParams } = params;
+        switch (operation) {
+            case 'file-read':
+                return this.octokit.rest.repos.getContent({
+                    owner,
+                    repo,
+                    path,
+                    ...otherParams
+                });
+            // Compatibility alias: return directory listing or file content metadata
+            case 'listFiles': {
+                // If path is omitted, list repository root
+                const listPath = path || '';
+                const response = await this.octokit.rest.repos.getContent({
+                    owner,
+                    repo,
+                    path: listPath,
+                    ...otherParams
+                });
+                // If response is an array, it's a directory listing
+                const data = Array.isArray(response.data)
+                    ? response.data.map((item) => ({
+                        name: item.name,
+                        path: item.path,
+                        sha: item.sha,
+                        type: item.type,
+                        size: item.size,
+                        url: item.html_url || item.url
+                    }))
+                    : ({
+                        name: response.data.name,
+                        path: response.data.path,
+                        sha: response.data.sha,
+                        type: response.data.type,
+                        size: response.data.size,
+                        url: response.data.html_url || response.data.url
+                    });
+                return { status: 200, data };
+            }
+            // Compatibility alias: get raw file content and normalize return
+            case 'getFile': {
+                const res = await this.octokit.rest.repos.getContent({
+                    owner,
+                    repo,
+                    path,
+                    ...otherParams
+                });
+                // GitHub returns base64 content for files
+                if (!res || !res.data) {
+                    throw new Error('Empty response from GitHub getContent');
+                }
+                // If this is a file object
+                const fileData = Array.isArray(res.data) ? res.data[0] : res.data;
+                const contentEncoded = fileData.content;
+                let contentDecoded = null;
+                if (contentEncoded) {
+                    contentDecoded = Buffer.from(contentEncoded, 'base64').toString('utf8');
+                }
+                return {
+                    status: 200,
+                    data: {
+                        filePath: fileData.path,
+                        sha: fileData.sha,
+                        encoding: fileData.encoding || (contentEncoded ? 'base64' : undefined),
+                        content: contentDecoded,
+                        size: fileData.size,
+                        url: fileData.html_url || fileData.url
+                    }
+                };
+            }
+            case 'file-create':
+                return this.octokit.rest.repos.createOrUpdateFileContents({
+                    owner,
+                    repo,
+                    path,
+                    message: params.message,
+                    content: params.content,
+                    ...otherParams
+                });
+            case 'file-update':
+                return this.octokit.rest.repos.createOrUpdateFileContents({
+                    owner,
+                    repo,
+                    path,
+                    message: params.message,
+                    content: params.content,
+                    sha: params.sha,
+                    ...otherParams
+                });
+            case 'file-delete':
+                return this.octokit.rest.repos.deleteFile({
+                    owner,
+                    repo,
+                    path,
+                    message: params.message,
+                    sha: params.sha,
+                    ...otherParams
+                });
+            case 'file-search':
+                return this.octokit.rest.search.code({
+                    q: `${params.query} repo:${owner}/${repo}`,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported file operation: ${operation}`);
+        }
     }
-    // Métodos stub para compatibilidade
-    async listIssues() { return []; }
-    async getIssue() { throw new Error('Not implemented'); }
-    async createIssue() { throw new Error('Not implemented'); }
-    async updateIssue() { throw new Error('Not implemented'); }
-    async closeIssue(owner, repo, issueNumber) {
-        const response = await this.client.patch(`/repos/${owner}/${repo}/issues/${issueNumber}`, {
-            state: 'closed'
-        });
-        return this.normalizeIssue(response.data);
+    /**
+     * Execute package operations
+     */
+    async executePackageOperation(operation, params) {
+        const { owner = this.githubConfig.username, ...otherParams } = params;
+        switch (operation) {
+            case 'package-list':
+                return this.octokit.rest.packages.listPackagesForUser({
+                    username: owner,
+                    package_type: params.package_type || 'npm',
+                    ...otherParams
+                });
+            case 'package-get':
+                return this.octokit.rest.packages.getPackageForUser({
+                    username: owner,
+                    package_type: params.package_type || 'npm',
+                    package_name: params.package_name,
+                    ...otherParams
+                });
+            case 'package-create':
+                // Package creation is typically done through package managers, not GitHub API
+                throw new Error('Package creation should be done through package managers (npm, etc.)');
+            case 'package-update':
+                // Package updates are typically done through package managers
+                throw new Error('Package updates should be done through package managers (npm, etc.)');
+            case 'package-delete':
+                return this.octokit.rest.packages.deletePackageForUser({
+                    username: owner,
+                    package_type: params.package_type || 'npm',
+                    package_name: params.package_name,
+                    ...otherParams
+                });
+            case 'package-publish':
+                // Package publishing is typically done through package managers
+                throw new Error('Package publishing should be done through package managers (npm, etc.)');
+            case 'package-download':
+                return this.octokit.rest.packages.getPackageVersionForUser({
+                    username: owner,
+                    package_type: params.package_type || 'npm',
+                    package_name: params.package_name,
+                    package_version_id: params.package_version_id,
+                    ...otherParams
+                });
+            default:
+                throw new Error(`Unsupported package operation: ${operation}`);
+        }
     }
-    async listPullRequests() { return []; }
-    async getPullRequest() { throw new Error('Not implemented'); }
-    async createPullRequest() { throw new Error('Not implemented'); }
-    async updatePullRequest() { throw new Error('Not implemented'); }
-    async mergePullRequest() { return false; }
-    async closePullRequest() { return false; }
-    async listReleases() { return []; }
-    async getRelease() { throw new Error('Not implemented'); }
-    async createRelease() { throw new Error('Not implemented'); }
-    async updateRelease() { throw new Error('Not implemented'); }
-    async deleteRelease() { return false; }
-    async listBranches() { return []; }
-    async getBranch() { throw new Error('Not implemented'); }
-    async createBranch() { throw new Error('Not implemented'); }
-    async deleteBranch() { return false; }
-    async listTags() { return []; }
-    async getTag() { throw new Error('Not implemented'); }
-    async createTag() { throw new Error('Not implemented'); }
-    async deleteTag() { return false; }
-    async getFileContent() { throw new Error('Not implemented'); }
-    async createFile() { throw new Error('Not implemented'); }
-    async updateFile() { throw new Error('Not implemented'); }
-    async deleteFile() { return false; }
-    async searchFiles() { return []; }
-    async listCommits() { return []; }
-    async getCommit() { throw new Error('Not implemented'); }
-    async compareCommits() { throw new Error('Not implemented'); }
-    async compareBranches() { throw new Error('Not implemented'); }
-    async transferRepository() { throw new Error('Not implemented'); }
-    async listJobs() { throw new Error('Not implemented'); }
-    async getUserRepositories() { return []; }
-    async listPackages() { return []; }
-    async getPackage() { throw new Error('Not implemented'); }
-    async createPackage() { throw new Error('Not implemented'); }
-    async updatePackage() { throw new Error('Not implemented'); }
-    async deletePackage() { return false; }
-    async publishPackage() { return false; }
-    async downloadPackage() { throw new Error('Not implemented'); }
-    async listProjects() { return []; }
-    async getProject() { throw new Error('Not implemented'); }
-    async createProject() { throw new Error('Not implemented'); }
-    async updateProject() { throw new Error('Not implemented'); }
-    async deleteProject() { return false; }
-    async addProjectItem() { throw new Error('Not implemented'); }
-    async updateProjectItem() { throw new Error('Not implemented'); }
-    async deleteProjectItem() { return false; }
-    async listProjectItems() { return []; }
 }
 exports.GitHubProvider = GitHubProvider;
 //# sourceMappingURL=github-provider.js.map