buddy-workbench 0.1.73 → 0.1.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.73",
+  "version": "0.1.74",
   "private": false,
   "type": "module",
   "bin": {

package/server/routes/pr-conflicts.js

@@ -87,9 +87,9 @@ async function findWorkspaceRepository(parsed) {
 
   for (const folder of candidates) {
     const identity = remoteIdentity(await getGitRemoteUrl(folder));
-    if (identity.projectKey === parsed.projectKey && identity.repositorySlug === parsed.repositorySlug) return folder;
+    if (identity.repositorySlug && parsed.repositorySlug && identity.repositorySlug.toLowerCase() === parsed.repositorySlug.toLowerCase()) return folder;
   }
-  throw new Error(`Could not find ${parsed.projectKey}/${parsed.repositorySlug} in workspace: ${workspaceDir}`);
+  throw new Error(`Could not find ${parsed.repositorySlug} in workspace: ${workspaceDir}`);
 }
 
 function validateRelativeFilePath(filePath) {
@@ -188,6 +188,74 @@ router.get('/my-conflicts', async (_req, res) => {
   }
 });
 
+router.post('/check-branch', async (req, res) => {
+  const parsed = parsePrUrl(req.body?.prUrl);
+  const branchName = typeof req.body?.branchName === 'string' ? req.body.branchName.trim() : '';
+  if (!branchName) return res.json({ exists: false });
+  if (!parsed) return res.status(400).json({ error: 'Invalid Pull Request URL.' });
+
+  // 1. Validate ref format
+  if (/[\s~^:?*\[\\]|\.\.|\/\.|\/\/|@\{|^\/|\/$|\.lock$/i.test(branchName)) {
+    return res.json({ exists: true, error: `Invalid branch name format: ${branchName}` });
+  }
+
+  // 2. Try checking local repo if workspace exists
+  try {
+    const folder = await findWorkspaceRepository(parsed);
+    try {
+      await git(folder, ['check-ref-format', '--branch', branchName]);
+    } catch {
+      return res.json({ exists: true, error: `Invalid branch name: ${branchName}` });
+    }
+
+    try {
+      await git(folder, ['rev-parse', '--verify', `refs/heads/${branchName}`]);
+      return res.json({ exists: true, error: `Local branch already exists: ${branchName}` });
+    } catch {}
+
+    try {
+      await git(folder, ['ls-remote', '--exit-code', '--heads', 'origin', branchName]);
+      return res.json({ exists: true, error: `Remote branch already exists on origin: ${branchName}` });
+    } catch {}
+  } catch {
+    // If local repo cannot be located, fallback to Bitbucket REST API
+    try {
+      const branchesUrl = `https://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.projectKey)}/repos/${encodeURIComponent(parsed.repositorySlug)}/branches?filterText=${encodeURIComponent(branchName)}&limit=10`;
+      const response = await client.get(branchesUrl, { headers: authHeaders() });
+      if (response.status >= 200 && response.status < 300) {
+        const values = Array.isArray(response.data?.values) ? response.data.values : [];
+        const found = values.find((b) => (b.displayId || b.id?.replace('refs/heads/', '')) === branchName);
+        if (found) {
+          return res.json({ exists: true, error: `Remote branch already exists on origin: ${branchName}` });
+        }
+      }
+    } catch {}
+  }
+
+  return res.json({ exists: false });
+});
+
+async function applyFileChoice(folder, filePath, choiceRef) {
+  try {
+    await git(folder, ['checkout', choiceRef, '--', filePath]);
+    await git(folder, ['add', '--', filePath]);
+  } catch {
+    const content = await readGitFile(folder, choiceRef, filePath);
+    const absolutePath = join(folder, filePath);
+    if (content === null) {
+      if (existsSync(absolutePath)) rmSync(absolutePath, { force: true, recursive: true });
+      try {
+        await git(folder, ['rm', '-f', '--', filePath]);
+      } catch {
+        await git(folder, ['add', '-A', '--', filePath]);
+      }
+    } else {
+      writeFileSync(absolutePath, content);
+      await git(folder, ['add', '--', filePath]);
+    }
+  }
+}
+
 router.post('/resolve', async (req, res) => {
   const parsed = parsePrUrl(req.body?.prUrl);
   const files = Array.isArray(req.body?.files) ? req.body.files : [];
@@ -228,7 +296,6 @@ router.post('/resolve', async (req, res) => {
     const targetRef = `origin/${targetBranch}`;
     await git(folder, ['rev-parse', '--verify', sourceRef]);
     await git(folder, ['rev-parse', '--verify', targetRef]);
-    await git(folder, ['checkout', '-B', sourceBranch, sourceRef]);
 
     let commitBranch = sourceBranch;
     if (createNewBranch) {
@@ -241,28 +308,48 @@ router.post('/resolve', async (req, res) => {
         await git(folder, ['ls-remote', '--exit-code', '--heads', 'origin', newBranchName]);
         return res.status(409).json({ error: `Remote branch already exists: ${newBranchName}` });
       } catch {}
-      await git(folder, ['checkout', '-b', newBranchName]);
+
+      // Checkout from target branch (b), then create resolution branch
+      await git(folder, ['checkout', '-B', newBranchName, targetRef]);
       commitBranch = newBranchName;
+
+      // Merge source branch (a) into resolution branch
+      try {
+        await git(folder, ['merge', '--no-commit', '--no-ff', sourceRef]);
+      } catch {
+        // Merge conflicts are expected and will be resolved per file choices
+      }
+    } else {
+      // Direct resolution on source branch (a) by merging target branch (b)
+      await git(folder, ['checkout', '-B', sourceBranch, sourceRef]);
+      commitBranch = sourceBranch;
+
+      try {
+        await git(folder, ['merge', '--no-commit', '--no-ff', targetRef]);
+      } catch {
+        // Merge conflicts are expected and will be resolved per file choices
+      }
     }
 
     const resolvedPaths = [];
     for (const file of files) {
       const filePath = validateRelativeFilePath(file.path);
       const choiceRef = choices[file.path] === 'target' ? targetRef : sourceRef;
-      const content = await readGitFile(folder, choiceRef, filePath);
-      const absolutePath = join(folder, filePath);
-      if (content === null) {
-        if (choices[file.path] === 'target' && existsSync(absolutePath)) rmSync(absolutePath);
-        else if (choices[file.path] === 'source') throw new Error(`File not found on source branch: ${filePath}`);
-      } else {
-        writeFileSync(absolutePath, content);
-      }
+      await applyFileChoice(folder, filePath, choiceRef);
       resolvedPaths.push(filePath);
     }
 
-    await git(folder, ['add', '--', ...resolvedPaths]);
-    const staged = String(await git(folder, ['diff', '--cached', '--name-only'])).trim();
-    if (!staged) return res.status(409).json({ error: 'No file changes to commit. The selected versions already match the source branch.' });
+    // Resolve any remaining unmerged paths that might not have been in the files array
+    const unmergedStr = String(await git(folder, ['diff', '--name-only', '--diff-filter=U'])).trim();
+    if (unmergedStr) {
+      const unmergedFiles = unmergedStr.split('\n').map((s) => s.trim()).filter(Boolean);
+      for (const unmergedFile of unmergedFiles) {
+        const choiceRef = choices[unmergedFile] === 'target' ? targetRef : sourceRef;
+        await applyFileChoice(folder, unmergedFile, choiceRef);
+      }
+    }
+
+    // Commit merge resolution
     await git(folder, ['commit', '-m', commitMessage]);
     await git(folder, ['push', 'origin', commitBranch]);
     const commitId = String(await git(folder, ['rev-parse', 'HEAD'])).trim();
@@ -272,7 +359,7 @@ router.post('/resolve', async (req, res) => {
       const createPrUrl = `https://${parsed.host}/rest/api/latest/projects/${encodeURIComponent(parsed.projectKey)}/repos/${encodeURIComponent(parsed.repositorySlug)}/pull-requests`;
       const createPrResponse = await client.post(createPrUrl, {
         title: commitMessage,
-        description: `Resolution Pull Request created from ${commitBranch}.\n\nThis branch contains the selected resolutions for Pull Request #${parsed.pullRequestId}.`,
+        description: `Resolution Pull Request created from ${commitBranch}.\n\nThis branch resolves conflicts for Pull Request #${parsed.pullRequestId} (${sourceBranch} → ${targetBranch}).`,
         fromRef: {
           id: `refs/heads/${commitBranch}`,
           repository: { slug: parsed.repositorySlug, project: { key: parsed.projectKey } }
@@ -300,10 +387,16 @@ router.post('/resolve', async (req, res) => {
       prUrl: resolutionPrUrl
     });
   } catch (error) {
-    res.status(500).json({ error: `Unable to create resolution commit: ${error.stderr || error.message}` });
+    const errorMsg = (error.stderr ? String(error.stderr).trim() : '') || error.message || String(error);
+    res.status(500).json({ error: `Unable to create resolution commit: ${errorMsg}` });
   } finally {
     if (folder) {
       try {
+        if (existsSync(join(folder, '.git', 'MERGE_HEAD'))) {
+          await git(folder, ['merge', '--abort']).catch(() => {});
+        }
+        await git(folder, ['reset', '--hard', 'HEAD']).catch(() => {});
+        await git(folder, ['clean', '-fd']).catch(() => {});
         if (originalBranch) await git(folder, ['checkout', originalBranch]);
         else if (originalHead) await git(folder, ['checkout', '--detach', originalHead]);
       } catch {}