buddy-workbench 0.1.72 → 0.1.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "private": false,
   "type": "module",
   "bin": {
@@ -59,5 +59,8 @@
     "@jsquash/jpeg": "1.6.0",
     "axios": "1.7.9",
     "express": "5.1.0"
+  },
+  "overrides": {
+    "content-type": "2.0.0"
   }
 }

package/server/routes/overview.js

@@ -3,8 +3,6 @@ import axios from 'axios';
 import { Router } from 'express';
 import { readSettings } from '../repositories/settings.js';
 import { listTodos } from '../repositories/todos.js';
-import { listBranchSyncApps } from '../repositories/branch-sync.js';
-import { getPresentations } from '../repositories/presentations.js';
 import { recordApiError } from '../lib/api-errors.js';
 
 const router = Router();
@@ -16,16 +14,6 @@ const httpClient = axios.create({
 
 const isSuccess = (response) => response.status >= 200 && response.status < 300;
 const apiMessage = (response, fallback) => response?.data?.errors?.[0]?.message || response?.data?.errorMessages?.[0] || response?.data?.message || response?.statusText || fallback;
-const getPresentationInsights = () => getPresentations().plans
-  .slice()
-  .sort((a, b) => Number(b.updatedAt || b.createdAt || 0) - Number(a.updatedAt || a.createdAt || 0))
-  .map((plan) => ({
-    id: plan.id,
-    title: plan.title || plan.name || 'Untitled presentation',
-    summary: `${Array.isArray(plan.sections) ? plan.sections.length : 0} sections`,
-    updated: plan.updatedAt || plan.createdAt || null,
-    url: '#/presentation-plan'
-  }));
 
 function jiraHost(domain) {
   const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
@@ -39,20 +27,7 @@ function bitbucketHost(domain) {
   return clean.includes('bitbucket') ? clean : `bitbucket.${clean}`;
 }
 
-function parseRepo(repo) {
-  const raw = String(repo || '').replace(/\.git$/i, '');
-  try {
-    const url = new URL(raw.startsWith('ssh://') ? raw.replace(/^ssh:\/\//i, 'https://') : raw);
-    const parts = url.pathname.split('/').filter(Boolean);
-    if (parts[0] === 'scm' && parts.length >= 3) return { host: url.host, project: parts[1], slug: parts[2] };
-    if ((parts[0] === 'projects' || parts[0] === 'users') && parts.length >= 4) return { host: url.host, project: parts[0] === 'users' ? `~${parts[1]}` : parts[1], slug: parts[3] };
-    if (parts.length >= 2) return { host: url.host, project: parts.at(-2), slug: parts.at(-1) };
-  } catch {}
-  return null;
-}
-
 function jiraUrl(host, path) { return `https://${host}/rest/api/2${path}`; }
-function bitbucketUrl(host, path) { return `https://${host}/rest/api/latest${path}`; }
 
 async function requestSection(name, loader) {
   try {
@@ -95,10 +70,9 @@ async function loadJiraData(host, token) {
   const identity = { accountId: me.accountId || '', name: me.name || '', displayName: me.displayName || '' };
   const fields = 'summary,status,priority,duedate,updated,assignee,reporter';
 
-  const [due, activity, blocked] = await Promise.all([
+  const [due, activity] = await Promise.all([
     searchJira(host, token, 'assignee = currentUser() AND due = startOfDay() AND resolution = Unresolved ORDER BY priority DESC', fields),
-    searchJira(host, token, 'updated >= -14d AND resolution = Unresolved AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC', fields, 30),
-    searchJira(host, token, 'status = Blocked AND updated <= -3d AND resolution = Unresolved ORDER BY updated ASC', fields)
+    searchJira(host, token, 'updated >= -14d AND resolution = Unresolved AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC', fields, 30)
   ]);
 
   const activityItems = [];
@@ -130,15 +104,14 @@ async function loadJiraData(host, token) {
   return {
     identity,
     dueToday: due.map((issue) => ({ ...mapJiraIssue(issue), url: issueUrl(host, issue.key) })),
-    activity: activityItems.map((item) => ({ ...item, url: issueUrl(host, item.key) })),
-    blocked: blocked.map((issue) => ({ ...mapJiraIssue(issue), url: issueUrl(host, issue.key) }))
+    activity: activityItems.map((item) => ({ ...item, url: issueUrl(host, item.key) }))
   };
 }
 
-async function loadPullRequests(host, token, role) {
-  const url = `https://${host}/rest/api/latest/dashboard/pull-requests?role=${role}&state=OPEN&limit=100`;
+async function loadAuthoredPullRequests(host, token) {
+  const url = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
   const response = await httpClient.get(url, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
-  if (!isSuccess(response)) throw new Error(`Bitbucket ${role} pull requests failed (${response.status}): ${apiMessage(response, 'Request failed')}`);
+  if (!isSuccess(response)) throw new Error(`Bitbucket author pull requests failed (${response.status}): ${apiMessage(response, 'Request failed')}`);
   return (response.data?.values || []).map((pr) => ({
     id: pr.id,
     title: pr.title || `Pull request #${pr.id}`,
@@ -149,65 +122,21 @@ async function loadPullRequests(host, token, role) {
   }));
 }
 
-async function loadFailedBuilds(host, token) {
-  const settings = readSettings();
-  const apps = listBranchSyncApps();
-  const repos = [];
-  for (const app of apps) {
-    for (const branch of [...new Set([app.activeBranch, app.lastReleaseBranch, 'master'].filter(Boolean))]) {
-      repos.push({ name: app.name, repo: app.repo, branch });
-    }
-    for (const sub of app.subApps || []) {
-      for (const branch of [...new Set([sub.branch, app.activeBranch, 'master'].filter(Boolean))]) {
-        repos.push({ name: sub.name || sub.directory, repo: sub.repo, branch });
-      }
-    }
-  }
-  const unique = [...new Map(repos.map((item) => [`${item.repo}|${item.branch}`, item])).values()];
-  const failed = [];
-  for (const item of unique.slice(0, 30)) {
-    const parsed = parseRepo(item.repo);
-    if (!parsed || (parsed.host && parsed.host !== host && !parsed.host.includes('bitbucket'))) continue;
-    const commitUrl = bitbucketUrl(parsed.host || host, `/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}/commits?until=${encodeURIComponent(item.branch)}&limit=1`);
-    const commitResponse = await httpClient.get(commitUrl, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
-    if (!isSuccess(commitResponse)) {
-      recordApiError({ source: 'Overview (Bitbucket Builds)', method: 'GET', url: commitUrl, status: commitResponse.status, message: apiMessage(commitResponse, 'Failed to fetch branch commit.') });
-      continue;
-    }
-    const hash = commitResponse.data?.values?.[0]?.id;
-    if (!hash) continue;
-    const buildUrl = `https://${parsed.host || host}/rest/api/latest/projects/${encodeURIComponent(parsed.project)}/repos/${encodeURIComponent(parsed.slug)}/commits/${encodeURIComponent(hash)}/builds`;
-    const buildResponse = await httpClient.get(buildUrl, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
-    if (!isSuccess(buildResponse)) {
-      if (buildResponse.status !== 404) recordApiError({ source: 'Overview (Bitbucket Builds)', method: 'GET', url: buildUrl, status: buildResponse.status, message: apiMessage(buildResponse, 'Failed to fetch build status.') });
-      continue;
-    }
-    for (const build of buildResponse.data?.values || []) {
-      if (String(build.state || '').toUpperCase() === 'FAILED') {
-        failed.push({ name: item.name, branch: item.branch, repository: item.repo, build: build.name || build.key || 'Build', date: build.dateAdded || null, url: item.repo });
-      }
-    }
-  }
-  return failed;
-}
-
 router.get('/', async (_req, res) => {
   const settings = readSettings();
-  const missingTokens = ['jira', 'bitbucket', 'confluence'].filter((service) => !settings[`${service}AccessToken`]);
+  const missingTokens = ['jira', 'bitbucket'].filter((service) => !settings[`${service}AccessToken`]);
   if (missingTokens.length > 0) {
-    return res.json({ configured: false, missingTokens, fetchedAt: new Date().toISOString(), categories: { presentations: getPresentationInsights() } });
+    return res.json({ configured: false, missingTokens, fetchedAt: new Date().toISOString(), categories: {} });
   }
   const jira = jiraHost(settings.domain);
   const bitbucket = bitbucketHost(settings.domain);
-  if (!jira || !bitbucket) return res.json({ configured: false, missingTokens: ['domain'], fetchedAt: new Date().toISOString(), categories: { presentations: getPresentationInsights() } });
+  if (!jira || !bitbucket) return res.json({ configured: false, missingTokens: ['domain'], fetchedAt: new Date().toISOString(), categories: {} });
 
   const sections = await Promise.all([
     requestSection('Jira', () => loadJiraData(jira, settings.jiraAccessToken)),
-    requestSection('Bitbucket Review', () => loadPullRequests(bitbucket, settings.bitbucketAccessToken, 'reviewer')),
-    requestSection('Bitbucket Author', () => loadPullRequests(bitbucket, settings.bitbucketAccessToken, 'author')),
-    requestSection('Bitbucket Builds', () => loadFailedBuilds(bitbucket, settings.bitbucketAccessToken))
+    requestSection('Bitbucket Author', () => loadAuthoredPullRequests(bitbucket, settings.bitbucketAccessToken))
   ]);
-  const [jiraData, reviewPrs, authoredPrs, failedBuilds] = sections;
+  const [jiraData, authoredPrs] = sections;
   const todos = listTodos().filter((todo) => !todo.completed && !todo.archived).map((todo) => ({ ...todo, url: '#/todo-list' }));
   const errors = sections.filter((section) => section.error).map((section) => section.error);
   res.json({
@@ -215,14 +144,10 @@ router.get('/', async (_req, res) => {
     missingTokens: [],
     fetchedAt: new Date().toISOString(),
     categories: {
+      activity: jiraData.items?.activity || [],
       jiraDueToday: jiraData.items?.dueToday || [],
       assignedTodos: todos,
-      reviewPrs: reviewPrs.items || [],
-      authoredPrs: authoredPrs.items || [],
-      failedBuilds: failedBuilds.items || [],
-      activity: jiraData.items?.activity || [],
-      blockedIssues: jiraData.items?.blocked || [],
-      presentations: getPresentationInsights()
+      authoredPrs: authoredPrs.items || []
     },
     errors
   });

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 {}