deepdebug-local-agent 0.3.1 → 0.3.2

package/src/server.js

@@ -734,6 +734,71 @@ app.post("/workspace/open", async (req, res) => {
     res.json({ ok: true, root: WORKSPACE_ROOT, workspaceId: wsId, meta, port });
 });
 
+/**
+ * POST /workspace/clone
+ * Clones a git repository into the local filesystem, then opens it as workspace.
+ * Body: { gitUrl, targetPath, workspaceId? }
+ */
+app.post("/workspace/clone", async (req, res) => {
+    const { gitUrl, targetPath, workspaceId } = req.body || {};
+
+    if (!gitUrl)     return res.status(400).json({ ok: false, error: "gitUrl is required" });
+    if (!targetPath) return res.status(400).json({ ok: false, error: "targetPath is required" });
+
+    const absTarget = path.resolve(targetPath);
+    console.log(`📥 Clone request: ${gitUrl} -> ${absTarget}`);
+
+    try {
+        // Ensure parent directory exists
+        const parentDir = path.dirname(absTarget);
+        await fsPromises.mkdir(parentDir, { recursive: true });
+
+        // If already cloned, do git pull instead
+        const gitDir = path.join(absTarget, '.git');
+        const alreadyCloned = await exists(gitDir);
+
+        if (alreadyCloned) {
+            console.log(`🔄 Repo already exists at ${absTarget}, running git pull...`);
+            const { stdout } = await execAsync('git pull', { cwd: absTarget, timeout: 120000 });
+            console.log(`✅ git pull: ${stdout.trim()}`);
+        } else {
+            console.log(`🔽 Running: git clone "${gitUrl}" "${absTarget}"`);
+            await execAsync(`git clone "${gitUrl}" "${absTarget}"`, { timeout: 300000 });
+            console.log(`✅ Clone complete: ${absTarget}`);
+        }
+
+        // Open the cloned workspace
+        WORKSPACE_ROOT = absTarget;
+        const wsId = workspaceId || "default";
+        try {
+            await wsManager.open(wsId, absTarget);
+        } catch (err) {
+            console.warn(`⚠️ WorkspaceManager.open failed (non-fatal): ${err.message}`);
+        }
+
+        const meta = await detectProject(absTarget);
+        const port = await detectPort(absTarget);
+
+        res.json({
+            ok: true,
+            path: absTarget,
+            workspaceId: wsId,
+            meta,
+            port,
+            message: alreadyCloned ? "Repository updated (git pull)" : "Repository cloned successfully"
+        });
+
+    } catch (err) {
+        console.error(`❌ Clone failed: ${err.message}`);
+        const hint = err.message.includes('Authentication') || err.message.includes('could not read')
+            ? "Authentication failed. Ensure the repo is public or GitHub integration is configured."
+            : err.message.includes('not found') || err.message.includes('does not exist')
+                ? "Repository not found. Check the URL is correct."
+                : "Clone failed. Ensure git is installed and the URL is accessible.";
+        res.status(500).json({ ok: false, error: err.message, hint });
+    }
+});
+
 /** Info do workspace */
 app.get("/workspace/info", async (_req, res) => {
     if (!WORKSPACE_ROOT) return res.status(400).json({ error: "workspace not set" });
@@ -4220,7 +4285,9 @@ app.post("/workspace/git/create-fix-branch", async (req, res) => {
                         .replace(/^https?:\/\/(.*@)?bitbucket\.org\//, '')
                         .replace(/^git@bitbucket\.org:/, '')
                         .replace(/\.git$/, '');
-                    authenticatedUrl = `https://x-token-auth:${gitToken}@bitbucket.org/${repoPath}.git`;
+                    // ✅ FIXED: Bitbucket App Password auth — token já está no formato "username:appPassword"
+                    // x-token-auth não funciona; Basic Auth via URL é o método correcto
+                    authenticatedUrl = `https://${gitToken}@bitbucket.org/${repoPath}.git`;
                 } else if (remoteUrlRaw) {
                     // Unknown provider — try generic https with token
                     const urlObj = new URL(remoteUrlRaw.replace(/^git@([^:]+):/, 'https://$1/'));
@@ -4348,52 +4415,140 @@ app.post("/workspace/git/create-fix-branch", async (req, res) => {
         } catch {}
 
         // 11. Auto-create Pull Request if pushed and token available
+        // ✅ FIXED: suporta GitHub, GitLab e Bitbucket; branding Insptech AI
         let prUrl = '';
-        if (pushed && gitToken && remoteUrl && remoteUrl.includes('github.com')) {
-            try {
-                const repoPath = remoteUrl
-                    .replace(/^https?:\/\/(.*@)?github\.com\//, '')
-                    .replace(/^git@github\.com:/, '')
-                    .replace(/\.git$/, '');
-
-                const prBody = {
-                    title: commitMessage,
-                    head: finalBranchName,
-                    base: targetBranch,
-                    body: `## 🤖 Auto-fix by DeepDebug AI\n\n` +
-                        `**Branch:** \`${finalBranchName}\`\n` +
-                        `**Files changed:** ${status.split('\n').length}\n` +
-                        `**Commit:** ${commitSha.substring(0, 8)}\n\n` +
-                        `This pull request was automatically created by DeepDebug AI after detecting and fixing a production error.\n\n` +
-                        `### Changes\n` +
-                        status.split('\n').map(l => `- \`${l.trim()}\``).join('\n') + '\n\n' +
-                        `---\n*Generated by [DeepDebug AI](https://deepdebug.ai) — Autonomous Debugging Platform*`
-                };
+        const prBodyText =
+            `## 🤖 Auto-fix by Insptech AI\n\n` +
+            `**Branch:** \`${finalBranchName}\`\n` +
+            `**Files changed:** ${status.split('\n').length}\n` +
+            `**Commit:** ${commitSha.substring(0, 8)}\n\n` +
+            `This pull request was automatically created by Insptech AI after detecting and fixing a production error.\n\n` +
+            `### Changes\n` +
+            status.split('\n').map(l => `- \`${l.trim()}\``).join('\n') + '\n\n' +
+            `---\n*Generated by [Insptech AI](https://app.insptech.pt) — Autonomous Debugging Platform*`;
+
+        if (pushed && gitToken && remoteUrl) {
+
+            // ── GitHub ──────────────────────────────────────────────────────
+            if (remoteUrl.includes('github.com')) {
+                try {
+                    const repoPath = remoteUrl
+                        .replace(/^https?:\/\/(.*@)?github\.com\//, '')
+                        .replace(/^git@github\.com:/, '')
+                        .replace(/\.git$/, '');
 
-                const response = await fetch(`https://api.github.com/repos/${repoPath}/pulls`, {
-                    method: 'POST',
-                    headers: {
-                        'Authorization': `Bearer ${gitToken}`,
-                        'Accept': 'application/vnd.github+json',
-                        'Content-Type': 'application/json',
-                        'X-GitHub-Api-Version': '2022-11-28'
-                    },
-                    body: JSON.stringify(prBody)
-                });
+                    const response = await fetch(`https://api.github.com/repos/${repoPath}/pulls`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${gitToken}`,
+                            'Accept': 'application/vnd.github+json',
+                            'Content-Type': 'application/json',
+                            'X-GitHub-Api-Version': '2022-11-28'
+                        },
+                        body: JSON.stringify({
+                            title: commitMessage,
+                            head: finalBranchName,
+                            base: targetBranch,
+                            body: prBodyText
+                        })
+                    });
 
-                if (response.ok) {
-                    const prData = await response.json();
-                    prUrl = prData.html_url;
-                    console.log(`✅ Pull Request created: ${prUrl}`);
-                } else {
-                    const errText = await response.text();
-                    console.warn(`⚠️ PR creation failed (${response.status}): ${errText.substring(0, 200)}`);
-                    // Still use the compare URL as fallback
+                    if (response.ok) {
+                        const prData = await response.json();
+                        prUrl = prData.html_url;
+                        console.log(`✅ GitHub PR created: ${prUrl}`);
+                    } else {
+                        const errText = await response.text();
+                        console.warn(`⚠️ GitHub PR creation failed (${response.status}): ${errText.substring(0, 200)}`);
+                        prUrl = mrUrl;
+                    }
+                } catch (prErr) {
+                    console.warn(`⚠️ GitHub PR error: ${prErr.message}`);
+                    prUrl = mrUrl;
+                }
+
+                // ── GitLab ──────────────────────────────────────────────────────
+            } else if (remoteUrl.includes('gitlab.com') || remoteUrl.includes('gitlab')) {
+                try {
+                    const hostMatch = remoteUrl.match(/https?:\/\/([^\/]+)/);
+                    const host = hostMatch ? hostMatch[1] : 'gitlab.com';
+                    const repoPath = remoteUrl
+                        .replace(/^https?:\/\/(.*@)?[^\/]+\//, '')
+                        .replace(/^git@[^:]+:/, '')
+                        .replace(/\.git$/, '');
+                    // GitLab API requer o path encoded (ex: "mygroup/myrepo" → "mygroup%2Fmyrepo")
+                    const encodedPath = encodeURIComponent(repoPath);
+
+                    const response = await fetch(`https://${host}/api/v4/projects/${encodedPath}/merge_requests`, {
+                        method: 'POST',
+                        headers: {
+                            'PRIVATE-TOKEN': gitToken,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            title: commitMessage,
+                            description: prBodyText,
+                            source_branch: finalBranchName,
+                            target_branch: targetBranch,
+                            remove_source_branch: false
+                        })
+                    });
+
+                    if (response.ok) {
+                        const mrData = await response.json();
+                        prUrl = mrData.web_url;
+                        console.log(`✅ GitLab MR created: ${prUrl}`);
+                    } else {
+                        const errText = await response.text();
+                        console.warn(`⚠️ GitLab MR creation failed (${response.status}): ${errText.substring(0, 200)}`);
+                        prUrl = mrUrl;
+                    }
+                } catch (glErr) {
+                    console.warn(`⚠️ GitLab MR error: ${glErr.message}`);
+                    prUrl = mrUrl;
+                }
+
+                // ── Bitbucket ────────────────────────────────────────────────────
+            } else if (remoteUrl.includes('bitbucket.org') || remoteUrl.includes('bitbucket')) {
+                try {
+                    const repoPath = remoteUrl
+                        .replace(/^https?:\/\/(.*@)?bitbucket\.org\//, '')
+                        .replace(/^git@bitbucket\.org:/, '')
+                        .replace(/\.git$/, '');
+                    const [workspace, repoSlug] = repoPath.split('/');
+
+                    // gitToken é "username:appPassword" — codificar para Basic Auth
+                    const credentials = Buffer.from(gitToken).toString('base64');
+
+                    const response = await fetch(
+                        `https://api.bitbucket.org/2.0/repositories/${workspace}/${repoSlug}/pullrequests`, {
+                            method: 'POST',
+                            headers: {
+                                'Authorization': `Basic ${credentials}`,
+                                'Content-Type': 'application/json'
+                            },
+                            body: JSON.stringify({
+                                title: commitMessage,
+                                description: prBodyText,
+                                source: { branch: { name: finalBranchName } },
+                                destination: { branch: { name: targetBranch } },
+                                close_source_branch: false
+                            })
+                        });
+
+                    if (response.ok) {
+                        const prData = await response.json();
+                        prUrl = prData.links && prData.links.html ? prData.links.html.href : mrUrl;
+                        console.log(`✅ Bitbucket PR created: ${prUrl}`);
+                    } else {
+                        const errText = await response.text();
+                        console.warn(`⚠️ Bitbucket PR creation failed (${response.status}): ${errText.substring(0, 200)}`);
+                        prUrl = mrUrl;
+                    }
+                } catch (bbErr) {
+                    console.warn(`⚠️ Bitbucket PR error: ${bbErr.message}`);
                     prUrl = mrUrl;
                 }
-            } catch (prErr) {
-                console.warn(`⚠️ PR creation error: ${prErr.message}`);
-                prUrl = mrUrl;
             }
         }
 
@@ -4456,6 +4611,396 @@ app.get("/workspace/git/status", async (req, res) => {
     }
 });
 
+// ============================================
+// 💬 PULL REQUEST COMMENTS ENDPOINTS
+// Read, reply, and resolve PR comments via git providers
+// Used by the frontend "Code Review" tab in incident detail
+// ============================================
+
+/**
+ * GET /workspace/git/pr/comments
+ *
+ * List all comments for a pull request.
+ * Detects provider (GitHub/Bitbucket) from remote URL.
+ *
+ * Query params:
+ *   - prNumber (required): PR/MR number
+ *   - filter: 'all' | 'unresolved' | 'review' (default: 'all')
+ */
+app.get("/workspace/git/pr/comments", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { prNumber, filter = 'all' } = req.query;
+
+    if (!prNumber) {
+        return res.status(400).json({ error: "prNumber query param is required" });
+    }
+
+    try {
+        const provider = await _getGitProvider();
+        if (!provider) {
+            return res.status(400).json({ error: "No git provider configured. Check remote URL and token." });
+        }
+
+        const { owner, repo } = provider.info;
+        let comments;
+
+        if (filter === 'unresolved') {
+            comments = await provider.instance.listUnresolvedPRComments(owner, repo, Number(prNumber));
+        } else if (filter === 'review') {
+            comments = await provider.instance.listPRReviewComments(owner, repo, Number(prNumber));
+        } else {
+            // Get both general and review comments, merge and sort by date
+            const [general, review] = await Promise.all([
+                provider.instance.listPRComments(owner, repo, Number(prNumber)).catch(() => []),
+                provider.instance.listPRReviewComments(owner, repo, Number(prNumber)).catch(() => [])
+            ]);
+
+            // Deduplicate by id
+            const seen = new Set();
+            comments = [...general, ...review].filter(c => {
+                if (seen.has(c.id)) return false;
+                seen.add(c.id);
+                return true;
+            });
+
+            // Sort by creation date
+            comments.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+        }
+
+        res.json({
+            ok: true,
+            prNumber: Number(prNumber),
+            filter,
+            comments,
+            total: comments.length,
+            unresolvedCount: comments.filter(c => c.resolved === false || c.resolved === undefined).length
+        });
+    } catch (err) {
+        console.error('❌ Failed to fetch PR comments:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * GET /workspace/git/pr/comments/:commentId
+ *
+ * Get a specific comment by ID.
+ *
+ * Query params:
+ *   - prNumber (required): PR/MR number
+ */
+app.get("/workspace/git/pr/comments/:commentId", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { commentId } = req.params;
+    const { prNumber } = req.query;
+
+    if (!prNumber) {
+        return res.status(400).json({ error: "prNumber query param is required" });
+    }
+
+    try {
+        const provider = await _getGitProvider();
+        if (!provider) {
+            return res.status(400).json({ error: "No git provider configured" });
+        }
+
+        const { owner, repo } = provider.info;
+        const comment = await provider.instance.getPRComment(owner, repo, Number(prNumber), commentId);
+
+        res.json({ ok: true, comment });
+    } catch (err) {
+        console.error('❌ Failed to fetch PR comment:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/git/pr/comments
+ *
+ * Add a comment to a pull request.
+ *
+ * Body:
+ *   - prNumber (required): PR/MR number
+ *   - body (required): Comment text (markdown)
+ *   - type: 'general' | 'review' (default: 'general')
+ *   - path: File path (required for type='review')
+ *   - line: Line number (required for type='review')
+ *   - side: 'LEFT' | 'RIGHT' (default: 'RIGHT')
+ *   - commitId: Commit SHA (for review comments)
+ *   - inReplyToId: Parent comment ID (for thread replies)
+ */
+app.post("/workspace/git/pr/comments", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { prNumber, body, type = 'general', path: filePath, line, side, commitId, inReplyToId } = req.body;
+
+    if (!prNumber) {
+        return res.status(400).json({ error: "prNumber is required" });
+    }
+    if (!body || !body.trim()) {
+        return res.status(400).json({ error: "body is required" });
+    }
+
+    try {
+        const provider = await _getGitProvider();
+        if (!provider) {
+            return res.status(400).json({ error: "No git provider configured" });
+        }
+
+        const { owner, repo } = provider.info;
+        let comment;
+
+        if (inReplyToId) {
+            // Reply to existing comment
+            comment = await provider.instance.replyToPRComment(owner, repo, Number(prNumber), inReplyToId, body);
+        } else if (type === 'review' && filePath) {
+            // Inline code comment
+            comment = await provider.instance.addPRReviewComment(owner, repo, Number(prNumber), {
+                body,
+                path: filePath,
+                line: line ? Number(line) : null,
+                side: side || 'RIGHT',
+                commitId,
+                inReplyToId
+            });
+        } else {
+            // General PR comment
+            comment = await provider.instance.addPRComment(owner, repo, Number(prNumber), body);
+        }
+
+        console.log(`💬 PR comment added to PR #${prNumber}: ${body.substring(0, 50)}...`);
+        res.json({ ok: true, comment });
+    } catch (err) {
+        console.error('❌ Failed to add PR comment:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/git/pr/comments/:commentId/resolve
+ *
+ * Mark a comment/thread as resolved.
+ *
+ * Body:
+ *   - prNumber (required): PR/MR number
+ */
+app.post("/workspace/git/pr/comments/:commentId/resolve", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { commentId } = req.params;
+    const { prNumber } = req.body;
+
+    if (!prNumber) {
+        return res.status(400).json({ error: "prNumber is required" });
+    }
+
+    try {
+        const provider = await _getGitProvider();
+        if (!provider) {
+            return res.status(400).json({ error: "No git provider configured" });
+        }
+
+        const { owner, repo } = provider.info;
+        const result = await provider.instance.resolvePRComment(owner, repo, Number(prNumber), commentId);
+
+        console.log(`✅ PR comment ${commentId} resolved on PR #${prNumber}`);
+        res.json({ ok: true, commentId, ...result });
+    } catch (err) {
+        console.error('❌ Failed to resolve PR comment:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/git/pr/comments/:commentId/unresolve
+ *
+ * Mark a comment/thread as unresolved.
+ *
+ * Body:
+ *   - prNumber (required): PR/MR number
+ */
+app.post("/workspace/git/pr/comments/:commentId/unresolve", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { commentId } = req.params;
+    const { prNumber } = req.body;
+
+    if (!prNumber) {
+        return res.status(400).json({ error: "prNumber is required" });
+    }
+
+    try {
+        const provider = await _getGitProvider();
+        if (!provider) {
+            return res.status(400).json({ error: "No git provider configured" });
+        }
+
+        const { owner, repo } = provider.info;
+        const result = await provider.instance.unresolvePRComment(owner, repo, Number(prNumber), commentId);
+
+        console.log(`🔄 PR comment ${commentId} unresolve on PR #${prNumber}`);
+        res.json({ ok: true, commentId, ...result });
+    } catch (err) {
+        console.error('❌ Failed to unresolve PR comment:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+/**
+ * POST /workspace/git/pr/comments/:commentId/fix-and-resolve
+ *
+ * AI-powered: Read the comment, understand the request, apply the code fix,
+ * commit, reply with explanation, and resolve the thread.
+ *
+ * This is the "magic" endpoint that makes DeepDebug unique.
+ *
+ * Body:
+ *   - prNumber (required): PR/MR number
+ *   - branch: Branch to apply fix on (defaults to current branch)
+ */
+app.post("/workspace/git/pr/comments/:commentId/fix-and-resolve", async (req, res) => {
+    if (!WORKSPACE_ROOT) {
+        return res.status(400).json({ error: "workspace not set" });
+    }
+
+    const { commentId } = req.params;
+    const { prNumber, branch } = req.body;
+
+    if (!prNumber) {
+        return res.status(400).json({ error: "prNumber is required" });
+    }
+
+    try {
+        const provider = await _getGitProvider();
+        if (!provider) {
+            return res.status(400).json({ error: "No git provider configured" });
+        }
+
+        const { owner, repo } = provider.info;
+
+        // 1. Fetch the comment
+        const comment = await provider.instance.getPRComment(owner, repo, Number(prNumber), commentId);
+
+        if (!comment) {
+            return res.status(404).json({ error: "Comment not found" });
+        }
+
+        console.log(`🤖 AI Fix & Resolve: PR #${prNumber}, comment ${commentId}`);
+        console.log(`   File: ${comment.path || '(general)'}, Line: ${comment.line || 'N/A'}`);
+        console.log(`   Request: ${comment.body.substring(0, 100)}...`);
+
+        // 2. Return the comment info for the Gateway to orchestrate the AI fix
+        // The actual AI analysis + patch is handled by the Gateway's AI service,
+        // not the Local Agent. We provide the context here.
+        res.json({
+            ok: true,
+            commentId,
+            prNumber: Number(prNumber),
+            comment: {
+                id: comment.id,
+                body: comment.body,
+                path: comment.path,
+                line: comment.line,
+                side: comment.side,
+                author: comment.authorUsername,
+                type: comment.type,
+                resolved: comment.resolved
+            },
+            context: {
+                owner,
+                repo,
+                branch: branch || null,
+                provider: provider.instance.getId()
+            },
+            // Action hint for the Gateway
+            action: 'fix_and_resolve',
+            message: 'Comment fetched. Gateway should now: 1) Read file, 2) AI analyze, 3) Apply patch, 4) Commit, 5) Reply, 6) Resolve'
+        });
+    } catch (err) {
+        console.error('❌ Failed to prepare fix-and-resolve:', err.message);
+        res.status(500).json({ ok: false, error: err.message });
+    }
+});
+
+
+// ============================================
+// 🔧 GIT PROVIDER HELPER (internal)
+// Detects provider from remote URL and configures with token
+// ============================================
+
+async function _getGitProvider() {
+    if (!WORKSPACE_ROOT) return null;
+
+    try {
+        const { execSync } = await import('child_process');
+        const opts = { cwd: WORKSPACE_ROOT, encoding: 'utf8', timeout: 5000 };
+
+        // Get remote URL
+        let remoteUrl;
+        try {
+            remoteUrl = execSync('git remote get-url origin', opts).trim();
+        } catch {
+            console.warn('⚠️ No git remote found');
+            return null;
+        }
+
+        // Detect provider from URL
+        const { getGitProviderRegistry } = await import('./git/git-provider-registry.js');
+        const registry = getGitProviderRegistry();
+        const providerId = registry.detectProviderFromUrl(remoteUrl);
+
+        if (!providerId) {
+            console.warn(`⚠️ Unknown git provider for URL: ${remoteUrl}`);
+            return null;
+        }
+
+        // Get token from environment
+        let token = null;
+        if (providerId === 'github') {
+            token = process.env.GITHUB_TOKEN || process.env.GIT_TOKEN;
+        } else if (providerId === 'bitbucket') {
+            token = process.env.BITBUCKET_TOKEN || process.env.BITBUCKET_APP_PASSWORD || process.env.GIT_TOKEN;
+        } else if (providerId === 'gitlab') {
+            token = process.env.GITLAB_TOKEN || process.env.GIT_TOKEN;
+        }
+
+        if (!token) {
+            console.warn(`⚠️ No token found for ${providerId}. Set ${providerId.toUpperCase()}_TOKEN or GIT_TOKEN env var.`);
+            return null;
+        }
+
+        // Create provider instance
+        const config = { accessToken: token };
+
+        // For Bitbucket App Password auth, add username
+        if (providerId === 'bitbucket' && process.env.BITBUCKET_USERNAME) {
+            config.username = process.env.BITBUCKET_USERNAME;
+            config.authMode = 'app_password';
+        }
+
+        const instance = registry.create(providerId, config);
+
+        // Parse owner/repo from URL
+        const info = instance.parseRepositoryUrl(remoteUrl);
+
+        return { instance, info, providerId, remoteUrl };
+    } catch (err) {
+        console.error('❌ Failed to initialize git provider:', err.message);
+        return null;
+    }
+}
 // ============================================
 // 📂 MULTI-WORKSPACE ENDPOINTS
 // ============================================