buddy-workbench 0.1.84 → 0.1.86

package/package.json

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

package/server/routes/pr-conflicts.js

@@ -39,6 +39,10 @@ function webPullRequestUrl(host, pr) {
   return `https://${host}/${projectPath}/repos/${repository}/pull-requests/${pr.id}`;
 }
 
+function pullRequestKey(project, repository, id) {
+  return `${project}/${repository}/${id}`;
+}
+
 async function git(folder, args, options = {}) {
   const result = await execFileAsync('git', args, {
     cwd: folder,
@@ -49,6 +53,31 @@ async function git(folder, args, options = {}) {
   return result.stdout;
 }
 
+async function detectConflictedPaths(folder, sourceRef, targetRef) {
+  try {
+    const output = await git(folder, [
+      'merge-tree',
+      '--write-tree',
+      '--name-only',
+      '-z',
+      '--no-messages',
+      targetRef,
+      sourceRef
+    ]);
+    return String(output)
+      .split('\0')
+      .map((path) => path.trim())
+      .filter((path) => path && !/^[0-9a-f]{40}$/i.test(path));
+  } catch (error) {
+    const output = String(error.stdout || '');
+    if (!output) throw error;
+    return output
+      .split('\0')
+      .map((path) => path.trim())
+      .filter((path) => path && !/^[0-9a-f]{40}$/i.test(path));
+  }
+}
+
 function remoteIdentity(remoteUrl) {
   const raw = String(remoteUrl || '').replace(/\.git$/i, '');
   let pathname = '';
@@ -226,6 +255,12 @@ export function UserProfile({ userId }: { userId: string }) {
           sourceContent: `{\n  "name": "enterprise-workbench",\n  "version": "2.4.0",\n  "endpoints": {\n    "auth": "https://auth.internal.company.com/oauth2/token",\n    "storage": "https://storage.internal.company.com/data"\n  }\n}`,
           targetContent: `{\n  "name": "enterprise-workbench",\n  "version": "2.3.1",\n  "endpoints": {\n    "auth": "https://auth-legacy.internal.company.com/token",\n    "storage": "https://storage.internal.company.com/data"\n  }\n}`,
           defaultChoice: 'target'
+        },
+        {
+          path: 'README.md',
+          sourceContent: '# Enterprise Workbench\n\nUpdated setup instructions for the new release.\n',
+          targetContent: '# Enterprise Workbench\n\nSetup instructions for the current release.\n',
+          conflicted: false
         }
       ]
     });
@@ -247,15 +282,26 @@ export function UserProfile({ userId }: { userId: string }) {
     const changes = changesResponse.data?.values || [];
     const sourceCommit = pr.fromRef?.latestCommit || pr.fromRef?.id;
     const targetCommit = pr.toRef?.latestCommit || pr.toRef?.id;
+    let conflictedPaths = null;
+    if (mergeResponse.data?.conflicted) {
+      try {
+        const folder = await findWorkspaceRepository(parsed);
+        await git(folder, ['fetch', 'origin', '--prune']);
+        const sourceRef = `origin/${pr.fromRef?.displayId}`;
+        const targetRef = `origin/${pr.toRef?.displayId}`;
+        conflictedPaths = new Set(await detectConflictedPaths(folder, sourceRef, targetRef));
+      } catch {}
+    }
     const files = await Promise.all(changes.map(async (change) => {
       const path = pathOf(change);
+      if (conflictedPaths && !conflictedPaths.has(path)) return null;
       const [sourceContent, targetContent] = await Promise.all([
         readFile({ ...parsed, commit: sourceCommit, path }),
         readFile({ ...parsed, commit: targetCommit, path })
       ]);
       return { path, sourceContent, targetContent, defaultChoice: 'source' };
     }));
-    res.json({ conflicted: Boolean(mergeResponse.data.conflicted), pr: { title: pr.title, sourceBranch: pr.fromRef?.displayId, targetBranch: pr.toRef?.displayId }, files: files.filter((file) => file.path) });
+    res.json({ conflicted: Boolean(mergeResponse.data.conflicted), pr: { title: pr.title, sourceBranch: pr.fromRef?.displayId, targetBranch: pr.toRef?.displayId }, files: files.filter((file) => file?.path).map((file) => ({ ...file, conflicted: conflictedPaths ? conflictedPaths.has(file.path) : true })) });
   } catch (error) {
     res.status(500).json({ error: `Unable to load conflict data: ${error.message}` });
   }
@@ -264,28 +310,54 @@ export function UserProfile({ userId }: { userId: string }) {
 router.get('/my-conflicts', async (_req, res) => {
   const host = configuredBitbucketHost();
   if (!host) return res.json({ values: [] });
-  const dashboardUrl = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=OPEN&limit=100`;
+  const dashboardUrl = `https://${host}/rest/api/latest/dashboard/pull-requests?role=author&state=ALL&limit=1000`;
   try {
     const response = await client.get(dashboardUrl, { headers: authHeaders() });
     if (response.status < 200 || response.status >= 300) return res.status(response.status).json({ error: `Unable to load authored Pull Requests (${response.status}).` });
     const values = Array.isArray(response.data?.values) ? response.data.values : [];
+    const resolutionPrs = new Map();
+    values.forEach((pr) => {
+      const project = pr.toRef?.repository?.project?.key;
+      const repository = pr.toRef?.repository?.slug;
+      const originalId = String(pr.description || '').match(/This branch resolves conflicts for Pull Request #(\d+)/i)?.[1];
+      if (project && repository && originalId && pr.id) {
+        resolutionPrs.set(pullRequestKey(project, repository, originalId), pr);
+      }
+    });
+
     const conflicts = await Promise.all(values.map(async (pr) => {
       const project = pr.toRef?.repository?.project?.key;
       const repository = pr.toRef?.repository?.slug;
       if (!project || !repository || !pr.id) return null;
-      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
-      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
-      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
-      return {
+      if (String(pr.description || '').match(/This branch resolves conflicts for Pull Request #\d+/i)) return null;
+
+      const resolutionPr = resolutionPrs.get(pullRequestKey(project, repository, pr.id));
+      const baseConflict = {
         id: pr.id,
         title: pr.title || `Pull Request #${pr.id}`,
+        repositoryName: pr.toRef?.repository?.name || repository,
         sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
         targetBranch: pr.toRef?.displayId || pr.toRef?.id,
         updatedDate: pr.updatedDate,
         url: webPullRequestUrl(host, pr)
       };
+      if (resolutionPr) {
+        return {
+          ...baseConflict,
+          resolutionPrUrl: webPullRequestUrl(host, resolutionPr),
+          resolutionPrId: resolutionPr.id
+        };
+      }
+
+      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
+      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
+      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
+      return baseConflict;
     }));
-    res.json({ values: conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0)) });
+    const sorted = conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0));
+    const unresolved = sorted.filter((pr) => !pr.resolutionPrUrl);
+    const resolved = sorted.filter((pr) => pr.resolutionPrUrl);
+    res.json({ values: unresolved, unresolved, resolved });
   } catch (error) {
     res.status(500).json({ error: `Unable to load authored Pull Requests: ${error.message}` });
   }

package/server/routes/pr-review.js

@@ -108,26 +108,80 @@ function getAiMessageContent(data) {
   return typeof content === 'string' ? content : '';
 }
 
+function cleanSummaryText(str) {
+  if (!str || typeof str !== 'string') return '';
+  let text = str.trim();
+  text = text.replace(/^```(?:markdown|md|json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+
+  const prefixRegex = /^\{?\s*\\?"?summary\\?"?\s*:\s*\\?"?/i;
+  if (prefixRegex.test(text)) {
+    text = text.replace(prefixRegex, '');
+    text = text.replace(/\\?"\s*,?\s*\\?"?findings\\?"?\s*:\s*\[[\s\S]*$/i, '');
+    text = text.replace(/\\?"\s*\}?\s*$/i, '');
+  }
+
+  return text
+    .replace(/\\n/g, '\n')
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
+    .replace(/\\t/g, '\t')
+    .trim();
+}
+
 function parseAiReview(content) {
-  const candidate = String(content || '').replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();
+  const raw = String(content || '').trim();
+  if (!raw) return { summary: '', findings: [] };
+
+  const sanitizeFindings = (arr) => {
+    if (!Array.isArray(arr)) return [];
+    return arr
+      .filter((finding) => finding && typeof finding.file === 'string' && finding.file.trim())
+      .map((finding) => ({
+        file: finding.file.trim(),
+        line: finding.line == null || finding.line === '' || !Number.isFinite(Number(finding.line)) ? null : Number(finding.line),
+        severity: ['critical', 'warning', 'info'].includes(finding.severity) ? finding.severity : 'warning',
+        title: typeof finding.title === 'string' && finding.title.trim() ? finding.title.trim() : 'AI finding',
+        explanation: typeof finding.explanation === 'string' ? finding.explanation.trim() : '',
+        recommendation: typeof finding.recommendation === 'string' ? finding.recommendation.trim() : ''
+      }));
+  };
+
+  const jsonMatch = raw.match(/```(?:json)?\s*([\s\S]*?)\s*```/i) || raw.match(/\{[\s\S]*\}/);
+  const candidate = jsonMatch ? (jsonMatch[1] || jsonMatch[0]).trim() : raw;
+
   try {
     const parsed = JSON.parse(candidate);
-    return {
-      summary: typeof parsed.summary === 'string' ? parsed.summary : '',
-      findings: Array.isArray(parsed.findings) ? parsed.findings
-        .filter((finding) => finding && typeof finding.file === 'string' && finding.file.trim())
-        .map((finding) => ({
-          file: finding.file.trim(),
-          line: finding.line == null || finding.line === '' || !Number.isFinite(Number(finding.line)) ? null : Number(finding.line),
-          severity: ['critical', 'warning', 'info'].includes(finding.severity) ? finding.severity : 'warning',
-          title: typeof finding.title === 'string' && finding.title.trim() ? finding.title.trim() : 'AI finding',
-          explanation: typeof finding.explanation === 'string' ? finding.explanation.trim() : '',
-          recommendation: typeof finding.recommendation === 'string' ? finding.recommendation.trim() : ''
-        })) : []
-    };
-  } catch {
-    return { summary: content, findings: [] };
+    if (parsed && typeof parsed === 'object') {
+      const summary = typeof parsed.summary === 'string' ? cleanSummaryText(parsed.summary) : '';
+      const findings = sanitizeFindings(parsed.findings);
+      if (summary || findings.length > 0) {
+        return { summary, findings };
+      }
+    }
+  } catch {}
+
+  let findings = [];
+  const findingsMatch = raw.match(/(?:\\?"findings\\?"|findings)\s*:\s*(\[[\s\S]*?\])/i);
+  if (findingsMatch) {
+    try {
+      findings = sanitizeFindings(JSON.parse(findingsMatch[1]));
+    } catch {
+      const itemRegex = /\{[\s\S]*?\}/g;
+      let itemMatch;
+      while ((itemMatch = itemRegex.exec(findingsMatch[1])) !== null) {
+        try {
+          findings.push(JSON.parse(itemMatch[0]));
+        } catch {}
+      }
+      findings = sanitizeFindings(findings);
+    }
   }
+
+  const summary = cleanSummaryText(raw);
+  return {
+    summary: summary || (findings.length > 0 ? '### 📋 PR Review Findings\n\nActionable findings found.' : ''),
+    findings
+  };
 }
 
 async function runAiReview({ aiApiHost, pr, files }) {

package/server/routes/updates.js

@@ -12,6 +12,7 @@ const packageJson = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
 const PACKAGE_NAME = packageJson.name;
 const CURRENT_VERSION = packageJson.version;
 const CACHE_TTL_MS = 15 * 60 * 1000;
+const RELEASE_VISIBILITY_AGE_MS = 48 * 60 * 60 * 1000;
 
 let cachedResult = null;
 let cachedAt = 0;
@@ -77,7 +78,9 @@ function buildReleaseList(metadata) {
     });
   }
 
+  const releaseCutoff = Date.now() - RELEASE_VISIBILITY_AGE_MS;
   return [...entriesByVersion.values()]
+    .filter((entry) => entry.publishedAt && new Date(entry.publishedAt).getTime() <= releaseCutoff)
     .sort((left, right) => compareVersions(right.version, left.version))
     .slice(0, 10);
 }