deepdebug-local-agent 0.3.1 → 0.3.2

package/src/git/bitbucket-provider.js

@@ -0,0 +1,723 @@
+import { BaseGitProvider } from './base-git-provider.js';
+import { run } from '../utils/exec-utils.js';
+
+/**
+ * BitbucketProvider
+ *
+ * Implementação do Git provider para Bitbucket Cloud.
+ *
+ * Bitbucket API 2.0: https://developer.atlassian.com/cloud/bitbucket/rest/intro/
+ *
+ * Authentication:
+ *   - App Password: Basic auth with username:app_password
+ *   - OAuth 2.0: Bearer token
+ *   - Repository Access Token: Bearer token (scoped to repo)
+ *
+ * Key differences from GitHub:
+ *   - API base: https://api.bitbucket.org/2.0
+ *   - Uses "workspace/repo_slug" instead of "owner/repo"
+ *   - Pull Requests are at /pullrequests (not /pulls)
+ *   - Branch creation is via refs/branches endpoint
+ *   - Paginated responses use { values: [], next: url }
+ *   - File content at /src endpoint (not /contents)
+ */
+export class BitbucketProvider extends BaseGitProvider {
+
+    constructor(config = {}) {
+        super(config);
+        this.clientId = config.clientId || process.env.BITBUCKET_CLIENT_ID;
+        this.clientSecret = config.clientSecret || process.env.BITBUCKET_CLIENT_SECRET;
+        // Bitbucket App Password auth requires username
+        this.username = config.username || process.env.BITBUCKET_USERNAME;
+        // Auth mode: 'app_password' (Basic) or 'oauth' (Bearer)
+        this.authMode = config.authMode || 'app_password';
+    }
+
+    // ==========================================
+    // IDENTIFICATION
+    // ==========================================
+
+    getId() {
+        return 'bitbucket';
+    }
+
+    getName() {
+        return 'Bitbucket';
+    }
+
+    getApiBaseUrl() {
+        return 'https://api.bitbucket.org/2.0';
+    }
+
+    // ==========================================
+    // AUTHENTICATION
+    // ==========================================
+
+    getAuthorizationUrl(redirectUri, state) {
+        const params = new URLSearchParams({
+            client_id: this.clientId,
+            redirect_uri: redirectUri,
+            response_type: 'code',
+            state
+        });
+
+        return `https://bitbucket.org/site/oauth2/authorize?${params}`;
+    }
+
+    async exchangeCodeForToken(code, redirectUri) {
+        const response = await fetch('https://bitbucket.org/site/oauth2/access_token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Authorization': 'Basic ' + Buffer.from(`${this.clientId}:${this.clientSecret}`).toString('base64')
+            },
+            body: new URLSearchParams({
+                grant_type: 'authorization_code',
+                code,
+                redirect_uri: redirectUri
+            }).toString()
+        });
+
+        const data = await response.json();
+
+        if (data.error) {
+            throw new Error(data.error_description || data.error);
+        }
+
+        this.accessToken = data.access_token;
+        this.authMode = 'oauth';
+
+        return {
+            accessToken: data.access_token,
+            tokenType: data.token_type,
+            refreshToken: data.refresh_token,
+            expiresIn: data.expires_in
+        };
+    }
+
+    async validateToken() {
+        try {
+            await this.getCurrentUser();
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    // ==========================================
+    // API HELPERS
+    // ==========================================
+
+    /**
+     * Build authorization headers based on auth mode.
+     *
+     * App Password: Basic base64(username:app_password)
+     * OAuth/Token:  Bearer <token>
+     */
+    _getAuthHeaders() {
+        if (this.authMode === 'app_password' && this.username) {
+            const credentials = Buffer.from(`${this.username}:${this.accessToken}`).toString('base64');
+            return { 'Authorization': `Basic ${credentials}` };
+        }
+        return { 'Authorization': `Bearer ${this.accessToken}` };
+    }
+
+    async apiRequest(endpoint, options = {}) {
+        const url = endpoint.startsWith('http')
+            ? endpoint
+            : `${this.getApiBaseUrl()}${endpoint}`;
+
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...this._getAuthHeaders(),
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            const msg = error.error?.message || error.error || `Bitbucket API error: ${response.status}`;
+            throw new Error(msg);
+        }
+
+        // Some endpoints (DELETE) return 204 No Content
+        if (response.status === 204) {
+            return {};
+        }
+
+        return response.json();
+    }
+
+    // ==========================================
+    // USER
+    // ==========================================
+
+    async getCurrentUser() {
+        const user = await this.apiRequest('/user');
+
+        return {
+            id: user.uuid,
+            username: user.username,
+            email: user.email || null,
+            name: user.display_name,
+            avatarUrl: user.links?.avatar?.href || null
+        };
+    }
+
+    // ==========================================
+    // REPOSITORIES
+    // ==========================================
+
+    async listRepositories(options = {}) {
+        const { page = 1, perPage = 25, sort = '-updated_on' } = options;
+
+        // Bitbucket uses workspace-based listing
+        const user = await this.getCurrentUser();
+        const data = await this.apiRequest(
+            `/repositories/${user.username}?page=${page}&pagelen=${perPage}&sort=${sort}`
+        );
+
+        return (data.values || []).map(repo => ({
+            id: repo.uuid,
+            name: repo.slug,
+            fullName: repo.full_name,
+            description: repo.description,
+            defaultBranch: repo.mainbranch?.name || 'main',
+            private: repo.is_private,
+            cloneUrl: this._extractCloneUrl(repo.links?.clone, 'https'),
+            htmlUrl: repo.links?.html?.href
+        }));
+    }
+
+    async getRepository(workspace, repoSlug) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}`);
+
+        return {
+            id: data.uuid,
+            name: data.slug,
+            fullName: data.full_name,
+            description: data.description,
+            defaultBranch: data.mainbranch?.name || 'main',
+            private: data.is_private,
+            cloneUrl: this._extractCloneUrl(data.links?.clone, 'https'),
+            htmlUrl: data.links?.html?.href
+        };
+    }
+
+    async cloneRepository(workspace, repoSlug, destPath, options = {}) {
+        const { branch, depth = 1 } = options;
+
+        const cloneUrl = this.getCloneUrl(workspace, repoSlug, true);
+
+        // Insert credentials in URL for authentication
+        let authedUrl;
+        if (this.authMode === 'app_password' && this.username) {
+            authedUrl = cloneUrl.replace(
+                'https://',
+                `https://${this.username}:${this.accessToken}@`
+            );
+        } else {
+            authedUrl = cloneUrl.replace(
+                'https://',
+                `https://x-token-auth:${this.accessToken}@`
+            );
+        }
+
+        const args = ['clone'];
+
+        if (depth) {
+            args.push('--depth', String(depth));
+        }
+
+        if (branch) {
+            args.push('--branch', branch);
+        }
+
+        args.push(authedUrl, destPath);
+
+        const result = await run('git', args);
+
+        return {
+            success: result.code === 0,
+            path: destPath,
+            output: result.stdout + result.stderr
+        };
+    }
+
+    // ==========================================
+    // BRANCHES
+    // ==========================================
+
+    async listBranches(workspace, repoSlug) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}/refs/branches`);
+
+        return (data.values || []).map(branch => ({
+            name: branch.name,
+            sha: branch.target?.hash,
+            protected: branch.name === branch.target?.repository?.mainbranch?.name
+        }));
+    }
+
+    async createBranch(workspace, repoSlug, branchName, fromRef) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}/refs/branches`, {
+            method: 'POST',
+            body: JSON.stringify({
+                name: branchName,
+                target: {
+                    hash: fromRef
+                }
+            })
+        });
+
+        return {
+            name: data.name,
+            sha: data.target?.hash,
+            protected: false
+        };
+    }
+
+    async getBranch(workspace, repoSlug, branch) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}/refs/branches/${branch}`);
+
+        return {
+            name: data.name,
+            sha: data.target?.hash,
+            protected: false
+        };
+    }
+
+    // ==========================================
+    // COMMITS
+    // ==========================================
+
+    async listCommits(workspace, repoSlug, branch, options = {}) {
+        const { page = 1, perPage = 30 } = options;
+
+        const data = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/commits/${branch}?page=${page}&pagelen=${perPage}`
+        );
+
+        return (data.values || []).map(commit => ({
+            sha: commit.hash,
+            message: commit.message,
+            authorName: commit.author?.raw?.split('<')[0]?.trim() || commit.author?.user?.display_name || 'Unknown',
+            authorEmail: commit.author?.raw?.match(/<(.+?)>/)?.[1] || '',
+            date: new Date(commit.date)
+        }));
+    }
+
+    async createCommit(workspace, repoSlug, branch, message, changes) {
+        // Bitbucket uses the /src endpoint with multipart form data for commits
+        // For simplicity, we use the API to push individual file changes
+        const formData = new FormData();
+
+        formData.append('message', message);
+        formData.append('branch', branch);
+
+        for (const change of changes) {
+            if (change.action === 'delete') {
+                formData.append('files', change.path);
+            } else {
+                formData.append(change.path, new Blob([change.content], { type: 'text/plain' }));
+            }
+        }
+
+        const url = `${this.getApiBaseUrl()}/repositories/${workspace}/${repoSlug}/src`;
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this._getAuthHeaders(),
+            body: formData
+        });
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(error.error?.message || `Bitbucket commit failed: ${response.status}`);
+        }
+
+        // Bitbucket returns 201 with no body on success, get latest commit
+        const commits = await this.listCommits(workspace, repoSlug, branch, { perPage: 1 });
+        const latestCommit = commits[0] || {};
+
+        return {
+            sha: latestCommit.sha || 'unknown',
+            message: message,
+            authorName: latestCommit.authorName || '',
+            authorEmail: latestCommit.authorEmail || '',
+            date: latestCommit.date || new Date()
+        };
+    }
+
+    // ==========================================
+    // FILES
+    // ==========================================
+
+    async getFileContent(workspace, repoSlug, filePath, ref = 'main') {
+        // Bitbucket /src endpoint returns raw file content
+        const url = `${this.getApiBaseUrl()}/repositories/${workspace}/${repoSlug}/src/${ref}/${filePath}`;
+
+        const response = await fetch(url, {
+            headers: this._getAuthHeaders()
+        });
+
+        if (!response.ok) {
+            throw new Error(`File not found: ${filePath} (${response.status})`);
+        }
+
+        const content = await response.text();
+
+        return {
+            path: filePath,
+            content: content,
+            sha: null, // Bitbucket doesn't return SHA for file content
+            encoding: 'utf-8'
+        };
+    }
+
+    async createOrUpdateFile(workspace, repoSlug, filePath, content, message, branch, sha = null) {
+        // Bitbucket uses /src endpoint with form data
+        const formData = new FormData();
+        formData.append('message', message);
+        formData.append('branch', branch);
+        formData.append(filePath, new Blob([content], { type: 'text/plain' }));
+
+        const url = `${this.getApiBaseUrl()}/repositories/${workspace}/${repoSlug}/src`;
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this._getAuthHeaders(),
+            body: formData
+        });
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(error.error?.message || `Failed to update file: ${response.status}`);
+        }
+
+        return {
+            path: filePath,
+            sha: null,
+            commit: { message }
+        };
+    }
+
+    // ==========================================
+    // PULL REQUESTS
+    // ==========================================
+
+    async listPullRequests(workspace, repoSlug, options = {}) {
+        const { state = 'OPEN', page = 1, perPage = 25 } = options;
+
+        const data = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests?state=${state}&page=${page}&pagelen=${perPage}`
+        );
+
+        return (data.values || []).map(pr => ({
+            number: pr.id,
+            title: pr.title,
+            body: pr.description,
+            state: pr.state,
+            head: pr.source?.branch?.name,
+            base: pr.destination?.branch?.name,
+            htmlUrl: pr.links?.html?.href
+        }));
+    }
+
+    async createPullRequest(workspace, repoSlug, pr) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}/pullrequests`, {
+            method: 'POST',
+            body: JSON.stringify({
+                title: pr.title,
+                description: pr.body || '',
+                source: {
+                    branch: { name: pr.head }
+                },
+                destination: {
+                    branch: { name: pr.base }
+                },
+                close_source_branch: true
+            })
+        });
+
+        return {
+            number: data.id,
+            title: data.title,
+            body: data.description,
+            state: data.state,
+            head: data.source?.branch?.name,
+            base: data.destination?.branch?.name,
+            htmlUrl: data.links?.html?.href
+        };
+    }
+
+    async getPullRequest(workspace, repoSlug, prId) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`);
+
+        return {
+            number: data.id,
+            title: data.title,
+            body: data.description,
+            state: data.state,
+            head: data.source?.branch?.name,
+            base: data.destination?.branch?.name,
+            htmlUrl: data.links?.html?.href
+        };
+    }
+
+    // ==========================================
+    // PULL REQUEST COMMENTS / REVIEWS
+    // ==========================================
+
+    /**
+     * List all comments on a pull request.
+     * Bitbucket has a single comments endpoint for both general and inline comments.
+     */
+    async listPRComments(workspace, repoSlug, prId, options = {}) {
+        const { page = 1, perPage = 50 } = options;
+
+        const data = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments?page=${page}&pagelen=${perPage}`
+        );
+
+        return (data.values || []).map(c => this._mapBitbucketComment(c));
+    }
+
+    /**
+     * List only inline (code review) comments on a PR.
+     * Filters comments that have inline.path set.
+     */
+    async listPRReviewComments(workspace, repoSlug, prId, options = {}) {
+        const allComments = await this.listPRComments(workspace, repoSlug, prId, options);
+        return allComments.filter(c => c.type === 'review' && c.path);
+    }
+
+    /**
+     * Get a specific comment by ID
+     */
+    async getPRComment(workspace, repoSlug, prId, commentId) {
+        const c = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}`
+        );
+        return this._mapBitbucketComment(c);
+    }
+
+    /**
+     * Add a general comment to a PR
+     */
+    async addPRComment(workspace, repoSlug, prId, body) {
+        const data = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    content: { raw: body }
+                })
+            }
+        );
+
+        return this._mapBitbucketComment(data);
+    }
+
+    /**
+     * Add an inline review comment on a specific line of code.
+     *
+     * @param {object} comment - { body, path, line, side, commitId }
+     *   - path: file path relative to repo root
+     *   - line: line number (Bitbucket uses 'to' for new side, 'from' for old side)
+     */
+    async addPRReviewComment(workspace, repoSlug, prId, comment) {
+        const requestBody = {
+            content: { raw: comment.body },
+            inline: {
+                path: comment.path
+            }
+        };
+
+        // Bitbucket uses 'to' for right/new side, 'from' for left/old side
+        if (comment.side === 'LEFT') {
+            requestBody.inline.from = comment.line;
+        } else {
+            requestBody.inline.to = comment.line;
+        }
+
+        const data = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`, {
+                method: 'POST',
+                body: JSON.stringify(requestBody)
+            }
+        );
+
+        return this._mapBitbucketComment(data);
+    }
+
+    /**
+     * Reply to an existing comment.
+     * Bitbucket uses parent.id to create threaded replies.
+     */
+    async replyToPRComment(workspace, repoSlug, prId, commentId, body) {
+        const data = await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    content: { raw: body },
+                    parent: { id: Number(commentId) }
+                })
+            }
+        );
+
+        return this._mapBitbucketComment(data);
+    }
+
+    /**
+     * Resolve a comment in Bitbucket.
+     * Bitbucket supports resolution natively via PUT with resolved=true.
+     */
+    async resolvePRComment(workspace, repoSlug, prId, commentId) {
+        await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}/resolve`, {
+                method: 'POST'
+            }
+        ).catch(async () => {
+            // Fallback: some Bitbucket versions use PUT with resolution object
+            await this.apiRequest(
+                `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}`, {
+                    method: 'PUT',
+                    body: JSON.stringify({
+                        resolution: {
+                            type: 'pullrequest_comment_resolution'
+                        }
+                    })
+                }
+            );
+        });
+
+        return { resolved: true };
+    }
+
+    /**
+     * Unresolve a comment in Bitbucket.
+     */
+    async unresolvePRComment(workspace, repoSlug, prId, commentId) {
+        await this.apiRequest(
+            `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}/resolve`, {
+                method: 'DELETE'
+            }
+        ).catch(async () => {
+            // Fallback: PUT without resolution
+            await this.apiRequest(
+                `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}`, {
+                    method: 'PUT',
+                    body: JSON.stringify({
+                        resolution: null
+                    })
+                }
+            );
+        });
+
+        return { resolved: false };
+    }
+
+    /**
+     * List only unresolved comments on a PR.
+     * Bitbucket API supports filtering by resolution status.
+     */
+    async listUnresolvedPRComments(workspace, repoSlug, prId) {
+        // Fetch all and filter - Bitbucket doesn't have a direct filter param
+        const allComments = await this.listPRComments(workspace, repoSlug, prId, { perPage: 100 });
+        return allComments.filter(c => c.resolved === false);
+    }
+
+    /**
+     * Map a Bitbucket comment response to our standard format
+     */
+    _mapBitbucketComment(c) {
+        const isInline = c.inline && c.inline.path;
+        return {
+            id: c.id,
+            body: c.content?.raw || c.content?.markup || '',
+            path: isInline ? c.inline.path : null,
+            line: isInline ? (c.inline.to || c.inline.from) : null,
+            side: isInline ? (c.inline.to ? 'RIGHT' : 'LEFT') : null,
+            commitId: null,
+            authorUsername: c.user?.username || c.user?.nickname,
+            authorName: c.user?.display_name,
+            createdAt: c.created_on,
+            updatedAt: c.updated_on,
+            htmlUrl: c.links?.html?.href || null,
+            resolved: c.resolution !== undefined && c.resolution !== null,
+            threadId: c.parent?.id || null,
+            inReplyToId: c.parent?.id || null,
+            type: isInline ? 'review' : 'general'
+        };
+    }
+
+    // ==========================================
+    // WEBHOOKS
+    // ==========================================
+
+    async createWebhook(workspace, repoSlug, webhook) {
+        const data = await this.apiRequest(`/repositories/${workspace}/${repoSlug}/hooks`, {
+            method: 'POST',
+            body: JSON.stringify({
+                description: webhook.description || 'InspTech AI Webhook',
+                url: webhook.url,
+                active: true,
+                events: webhook.events || ['repo:push', 'pullrequest:created', 'pullrequest:updated'],
+                secret: webhook.secret
+            })
+        });
+
+        return {
+            id: data.uuid,
+            url: data.url,
+            events: data.events,
+            active: data.active
+        };
+    }
+
+    // ==========================================
+    // HELPER METHODS
+    // ==========================================
+
+    getCloneUrl(workspace, repoSlug, useHttps = true) {
+        if (useHttps) {
+            return `https://bitbucket.org/${workspace}/${repoSlug}.git`;
+        }
+        return `git@bitbucket.org:${workspace}/${repoSlug}.git`;
+    }
+
+    parseRepositoryUrl(url) {
+        // Supports:
+        // - https://bitbucket.org/workspace/repo
+        // - https://bitbucket.org/workspace/repo.git
+        // - git@bitbucket.org:workspace/repo.git
+        // - https://username@bitbucket.org/workspace/repo.git
+
+        let match = url.match(/bitbucket\.org[/:]([\w-]+)\/([\w.-]+?)(?:\.git)?$/);
+
+        if (match) {
+            return {
+                owner: match[1],   // workspace in Bitbucket terminology
+                repo: match[2]     // repo_slug
+            };
+        }
+
+        throw new Error(`Invalid Bitbucket repository URL: ${url}`);
+    }
+
+    /**
+     * Extract clone URL from Bitbucket's links.clone array
+     * @param {Array} cloneLinks - Array of { name, href } objects
+     * @param {string} type - 'https' or 'ssh'
+     * @returns {string}
+     */
+    _extractCloneUrl(cloneLinks, type = 'https') {
+        if (!cloneLinks || !Array.isArray(cloneLinks)) return '';
+        const link = cloneLinks.find(l => l.name === type);
+        return link?.href || '';
+    }
+}
+
+export default BitbucketProvider;