buddy-workbench 0.1.76 → 0.1.78

package/package.json

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

package/server/routes/jira-filters.js

@@ -230,10 +230,311 @@ router.delete('/templates/:id', (req, res) => {
   res.status(204).end();
 });
 
+async function getJiraIdentity(jiraHost, token) {
+  const headers = { Accept: 'application/json', Authorization: token.startsWith('Bearer ') ? token : `Bearer ${token}` };
+  try {
+    const meResponse = await httpClient.get(`https://${jiraHost}/rest/api/2/myself`, { headers });
+    if (meResponse.status >= 200 && meResponse.status < 300 && meResponse.data) {
+      const me = meResponse.data;
+      return {
+        accountId: me.accountId || '',
+        name: me.name || me.key || '',
+        key: me.key || me.name || '',
+        displayName: me.displayName || '',
+        emailAddress: me.emailAddress || ''
+      };
+    }
+  } catch (err) {
+    recordApiError({ source: 'Jira API (myself)', method: 'GET', url: `https://${jiraHost}/rest/api/2/myself`, message: err.message });
+  }
+  return {};
+}
+
+function isAuthorMatch(author, identity) {
+  if (!author || typeof author !== 'object') return false;
+  const authorName = String(author.name || '').toLowerCase();
+  const authorKey = String(author.key || '').toLowerCase();
+  const authorAccountId = String(author.accountId || '').toLowerCase();
+  const authorDisplayName = String(author.displayName || '').toLowerCase();
+  const authorEmail = String(author.emailAddress || '').toLowerCase();
+
+  if (identity.name && (authorName === identity.name.toLowerCase() || authorKey === identity.name.toLowerCase())) return true;
+  if (identity.key && (authorKey === identity.key.toLowerCase() || authorName === identity.key.toLowerCase())) return true;
+  if (identity.accountId && authorAccountId === identity.accountId.toLowerCase()) return true;
+  if (identity.displayName && authorDisplayName === identity.displayName.toLowerCase()) return true;
+  if (identity.emailAddress && authorEmail === identity.emailAddress.toLowerCase()) return true;
+
+  return false;
+}
+
+function extractCommentBodyText(body) {
+  if (!body) return '';
+  if (typeof body === 'string') return body;
+  if (typeof body === 'object') {
+    try {
+      const extractTextFromAdf = (node) => {
+        if (!node) return '';
+        if (typeof node === 'string') return node;
+        if (node.type === 'text' && node.text) return node.text;
+        if (node.type === 'mention' && (node.attrs?.text || node.attrs?.id)) {
+          return `${node.attrs.text || node.attrs.id} `;
+        }
+        if (Array.isArray(node.content)) {
+          return node.content.map(extractTextFromAdf).join(' ');
+        }
+        return '';
+      };
+      const adfText = extractTextFromAdf(body).trim();
+      if (adfText) return adfText;
+      return JSON.stringify(body);
+    } catch {
+      return String(body || '');
+    }
+  }
+  return String(body || '');
+}
+
+function isMentionMatch(bodyText, author, identity) {
+  if (!bodyText) return false;
+  if (isAuthorMatch(author, identity)) return false;
+
+  const lower = bodyText.toLowerCase();
+  const terms = [
+    identity.name ? `[~${identity.name.toLowerCase()}]` : null,
+    identity.key ? `[~${identity.key.toLowerCase()}]` : null,
+    identity.name ? `@${identity.name.toLowerCase()}` : null,
+    identity.key ? `@${identity.key.toLowerCase()}` : null,
+    identity.name ? identity.name.toLowerCase() : null,
+    identity.key ? identity.key.toLowerCase() : null,
+    identity.accountId ? identity.accountId.toLowerCase() : null,
+    identity.displayName ? identity.displayName.toLowerCase() : null,
+    identity.emailAddress ? identity.emailAddress.toLowerCase() : null
+  ].filter(Boolean);
+
+  return terms.some((term) => lower.includes(term));
+}
+
+async function searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, fields = 'summary,priority,status,updated,assignee,reporter', maxResults = 50) {
+  for (const jql of jqlCandidates) {
+    if (!jql) continue;
+    try {
+      const searchUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}&fields=${encodeURIComponent(fields)}`;
+      const response = await httpClient.get(searchUrl, { headers });
+      if (response.status === 200 && Array.isArray(response.data?.issues) && response.data.issues.length > 0) {
+        return response.data.issues;
+      }
+    } catch {}
+  }
+  return [];
+}
+
+async function fetchCommentsForIssue(jiraHost, headers, issueKey, maxResults = 50) {
+  try {
+    const url = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?maxResults=${maxResults}`;
+    const response = await httpClient.get(url, { headers });
+    if (response.status !== 200) return [];
+    const total = response.data?.total || 0;
+    const comments = Array.isArray(response.data?.comments) ? response.data.comments : [];
+    if (total > comments.length && total > maxResults) {
+      const startAt = Math.max(0, total - maxResults);
+      const latestUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?startAt=${startAt}&maxResults=${maxResults}`;
+      const latestResponse = await httpClient.get(latestUrl, { headers });
+      if (latestResponse.status === 200 && Array.isArray(latestResponse.data?.comments)) {
+        return latestResponse.data.comments;
+      }
+    }
+    return comments;
+  } catch {
+    return [];
+  }
+}
+
 router.get('/recently-created', (_req, res) => {
   res.json(listRecentlyCreatedJiraIssues());
 });
 
+router.get('/recently-commented', async (_req, res) => {
+  const jiraHost = getJiraHost();
+  if (!jiraHost) return res.json([]);
+  const settings = readSettings();
+  const token = settings.jiraAccessToken;
+  if (!token) return res.json([]);
+
+  const headers = { Accept: 'application/json', Authorization: token.startsWith('Bearer ') ? token : `Bearer ${token}` };
+  try {
+    const identity = await getJiraIdentity(jiraHost, token);
+
+    const jqlCandidates = [];
+    if (identity.name) {
+      jqlCandidates.push(`comment ~ "\\"${identity.name}\\"" ORDER BY updated DESC`);
+      jqlCandidates.push(`comment ~ "${identity.name}" ORDER BY updated DESC`);
+    }
+    if (identity.displayName && identity.displayName !== identity.name) {
+      jqlCandidates.push(`comment ~ "\\"${identity.displayName}\\"" ORDER BY updated DESC`);
+    }
+    if (identity.accountId) {
+      jqlCandidates.push(`comment ~ "${identity.accountId}" ORDER BY updated DESC`);
+    }
+    jqlCandidates.push('(assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) AND updated >= -60d ORDER BY updated DESC');
+    jqlCandidates.push('updated >= -60d ORDER BY updated DESC');
+
+    const issues = await searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter', 40);
+    const results = [];
+
+    const issueCommentsPromises = issues.slice(0, 30).map(async (issue) => {
+      const key = issue.key;
+      const fields = issue.fields || {};
+      const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);
+
+      const myComments = comments.filter((c) => isAuthorMatch(c.author || c.updateAuthor, identity));
+      if (myComments.length > 0) {
+        myComments.sort((a, b) => new Date(b.updated || b.created || 0).getTime() - new Date(a.updated || a.created || 0).getTime());
+        const latestMyComment = myComments[0];
+        const bodyText = extractCommentBodyText(latestMyComment.body);
+        const commentSnippet = bodyText.slice(0, 140).replace(/\r?\n+/g, ' ');
+        const commentId = latestMyComment.id;
+
+        return {
+          id: `${issue.id}-${commentId || 'c'}`,
+          key,
+          summary: fields.summary || key,
+          priority: fields.priority?.name || '',
+          status: fields.status?.name || '',
+          commentSnippet,
+          commentedAt: latestMyComment.updated || latestMyComment.created || fields.updated,
+          url: `https://${jiraHost}/browse/${key}${commentId ? `?focusedCommentId=${commentId}#comment-${commentId}` : ''}`
+        };
+      }
+      return null;
+    });
+
+    const settled = await Promise.all(issueCommentsPromises);
+    for (const item of settled) {
+      if (item) results.push(item);
+    }
+
+    results.sort((a, b) => new Date(b.commentedAt || 0).getTime() - new Date(a.commentedAt || 0).getTime());
+    res.json(results);
+  } catch (error) {
+    recordApiError({ source: 'Jira (Recently Commented)', message: error.message });
+    res.json([]);
+  }
+});
+
+router.get('/recently-mentioned', async (_req, res) => {
+  const jiraHost = getJiraHost();
+  if (!jiraHost) return res.json([]);
+  const settings = readSettings();
+  const token = settings.jiraAccessToken;
+  if (!token) return res.json([]);
+
+  const headers = { Accept: 'application/json', Authorization: token.startsWith('Bearer ') ? token : `Bearer ${token}` };
+  try {
+    const identity = await getJiraIdentity(jiraHost, token);
+
+    const jqlCandidates = [];
+    if (identity.name) {
+      jqlCandidates.push(`text ~ "[~${identity.name}]" OR comment ~ "[~${identity.name}]" ORDER BY updated DESC`);
+      jqlCandidates.push(`text ~ "${identity.name}" OR comment ~ "${identity.name}" ORDER BY updated DESC`);
+      jqlCandidates.push(`text ~ "\\"${identity.name}\\"" ORDER BY updated DESC`);
+    }
+    if (identity.displayName && identity.displayName !== identity.name) {
+      jqlCandidates.push(`text ~ "\\"${identity.displayName}\\"" OR comment ~ "\\"${identity.displayName}\\"" ORDER BY updated DESC`);
+    }
+    if (identity.accountId) {
+      jqlCandidates.push(`text ~ "${identity.accountId}" OR comment ~ "${identity.accountId}" ORDER BY updated DESC`);
+    }
+    jqlCandidates.push('(assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) AND updated >= -60d ORDER BY updated DESC');
+    jqlCandidates.push('updated >= -60d ORDER BY updated DESC');
+
+    const issues = await searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter', 40);
+    const results = [];
+
+    const issueMentionsPromises = issues.slice(0, 30).map(async (issue) => {
+      const key = issue.key;
+      const fields = issue.fields || {};
+      const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);
+
+      const mentionComments = comments.filter((c) => {
+        const bodyText = extractCommentBodyText(c.body);
+        return isMentionMatch(bodyText, c.author || c.updateAuthor, identity);
+      });
+
+      if (mentionComments.length > 0) {
+        mentionComments.sort((a, b) => new Date(b.updated || b.created || 0).getTime() - new Date(a.updated || a.created || 0).getTime());
+        const latestMention = mentionComments[0];
+        const author = latestMention.author?.displayName || latestMention.author?.name || 'Someone';
+        const bodyText = extractCommentBodyText(latestMention.body);
+        const snippet = bodyText.slice(0, 140).replace(/\r?\n+/g, ' ');
+        const commentId = latestMention.id;
+
+        return {
+          id: `${issue.id}-${commentId || 'm'}`,
+          key,
+          summary: fields.summary || key,
+          priority: fields.priority?.name || '',
+          status: fields.status?.name || '',
+          mentionedBy: author,
+          mentionSnippet: snippet,
+          mentionedAt: latestMention.updated || latestMention.created || fields.updated,
+          url: `https://${jiraHost}/browse/${key}${commentId ? `?focusedCommentId=${commentId}#comment-${commentId}` : ''}`
+        };
+      }
+      return null;
+    });
+
+    const settled = await Promise.all(issueMentionsPromises);
+    for (const item of settled) {
+      if (item) results.push(item);
+    }
+
+    results.sort((a, b) => new Date(b.mentionedAt || 0).getTime() - new Date(a.mentionedAt || 0).getTime());
+    res.json(results);
+  } catch (error) {
+    recordApiError({ source: 'Jira (Recently Mentioned)', message: error.message });
+    res.json([]);
+  }
+});
+
+router.get('/recently-updated', async (_req, res) => {
+  const jiraHost = getJiraHost();
+  if (!jiraHost) return res.json([]);
+  const settings = readSettings();
+  const token = settings.jiraAccessToken;
+  if (!token) return res.json([]);
+
+  const headers = { Accept: 'application/json', Authorization: token.startsWith('Bearer ') ? token : `Bearer ${token}` };
+  try {
+    const jqlCandidates = [
+      'updatedBy(currentUser()) ORDER BY updated DESC',
+      '(assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) AND updated >= -60d ORDER BY updated DESC',
+      'assignee = currentUser() ORDER BY updated DESC',
+      'updated >= -60d ORDER BY updated DESC'
+    ];
+
+    const issues = await searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,duedate,assignee,reporter', 40);
+
+    const results = issues.map((issue) => {
+      const fields = issue.fields || {};
+      return {
+        id: issue.id,
+        key: issue.key,
+        summary: fields.summary || issue.key,
+        priority: fields.priority?.name || '',
+        status: fields.status?.name || '',
+        updatedAt: fields.updated || null,
+        dueDate: fields.duedate || null,
+        url: `https://${jiraHost}/browse/${issue.key}`
+      };
+    });
+
+    res.json(results);
+  } catch (error) {
+    recordApiError({ source: 'Jira (Recently Updated)', message: error.message });
+    res.json([]);
+  }
+});
+
 // Create filter
 router.post('/', (req, res) => {
   const { name, filterId } = req.body || {};

package/server/routes/overview.js

@@ -27,6 +27,12 @@ function bitbucketHost(domain) {
   return clean.includes('bitbucket') ? clean : `bitbucket.${clean}`;
 }
 
+function confluenceHost(domain) {
+  const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+  if (!clean) return '';
+  return clean.includes('confluence') ? clean : `confluence.${clean}`;
+}
+
 function jiraUrl(host, path) { return `https://${host}/rest/api/2${path}`; }
 
 async function requestSection(name, loader) {
@@ -39,8 +45,9 @@ async function requestSection(name, loader) {
 }
 
 async function searchJira(host, token, jql, fields, maxResults = 25) {
+  const authHeader = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
   const url = jiraUrl(host, `/search?jql=${encodeURIComponent(jql)}&maxResults=${maxResults}&fields=${encodeURIComponent(fields)}`);
-  const response = await httpClient.get(url, { headers: { Accept: 'application/json', Authorization: `Bearer ${token}` } });
+  const response = await httpClient.get(url, { headers: { Accept: 'application/json', Authorization: authHeader } });
   if (!isSuccess(response)) throw new Error(`Jira search failed (${response.status}): ${apiMessage(response, 'Request failed')}`);
   return response.data?.issues || [];
 }
@@ -62,55 +69,148 @@ function mapJiraIssue(issue) {
 function issueUrl(host, key) { return `https://${host}/browse/${encodeURIComponent(key)}`; }
 
 async function loadJiraData(host, token) {
-  const headers = { Accept: 'application/json', Authorization: `Bearer ${token}` };
+  const authHeader = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+  const headers = { Accept: 'application/json', Authorization: authHeader };
   const meUrl = jiraUrl(host, '/myself');
   const meResponse = await httpClient.get(meUrl, { headers });
   if (!isSuccess(meResponse)) throw new Error(`Jira identity lookup failed (${meResponse.status}): ${apiMessage(meResponse, 'Request failed')}`);
   const me = meResponse.data || {};
-  const identity = { accountId: me.accountId || '', name: me.name || '', displayName: me.displayName || '' };
+  const identity = { accountId: me.accountId || '', name: me.name || '', displayName: me.displayName || '', emailAddress: me.emailAddress || '' };
   const fields = 'summary,status,priority,duedate,updated,assignee,reporter';
 
-  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)
-  ]);
+  // 1. Due today issues
+  const due = await searchJira(host, token, 'assignee = currentUser() AND due = startOfDay() AND resolution = Unresolved ORDER BY priority DESC', fields).catch(() => []);
+
+  // 2. Mentioned / active issues
+  let activityIssues = [];
+  const jqlCandidates = [];
+  if (identity.name) {
+    jqlCandidates.push(`text ~ "[~${identity.name}]" OR comment ~ "[~${identity.name}]" ORDER BY updated DESC`);
+    jqlCandidates.push(`text ~ "${identity.name}" OR comment ~ "${identity.name}" ORDER BY updated DESC`);
+  }
+  if (identity.displayName && identity.displayName !== identity.name) {
+    jqlCandidates.push(`text ~ "\\"${identity.displayName}\\"" ORDER BY updated DESC`);
+  }
+  if (identity.accountId) {
+    jqlCandidates.push(`text ~ "${identity.accountId}" OR comment ~ "${identity.accountId}" ORDER BY updated DESC`);
+  }
+  jqlCandidates.push('updated >= -30d AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC');
+  jqlCandidates.push('updated >= -30d ORDER BY updated DESC');
+
+  for (const jql of jqlCandidates) {
+    try {
+      activityIssues = await searchJira(host, token, jql, fields, 30);
+      if (activityIssues.length > 0) break;
+    } catch {}
+  }
 
   const activityItems = [];
-  for (const issue of activity.slice(0, 15)) {
+  for (const issue of activityIssues.slice(0, 20)) {
     const key = issue.key;
-    const commentsUrl = jiraUrl(host, `/issue/${encodeURIComponent(key)}/comment?orderBy=-updated&maxResults=10`);
-    const commentsResponse = await httpClient.get(commentsUrl, { headers });
-    if (!isSuccess(commentsResponse)) {
-      recordApiError({ source: 'Overview (Jira Activity)', method: 'GET', url: commentsUrl, status: commentsResponse.status, message: apiMessage(commentsResponse, 'Failed to fetch comments.') });
-      continue;
+    const commentsUrl = jiraUrl(host, `/issue/${encodeURIComponent(key)}/comment?maxResults=50`);
+    const commentsResponse = await httpClient.get(commentsUrl, { headers }).catch(() => null);
+    let comments = commentsResponse && isSuccess(commentsResponse) ? (commentsResponse.data?.comments || []) : [];
+    const total = commentsResponse?.data?.total || 0;
+    if (total > comments.length && total > 50) {
+      const startAt = Math.max(0, total - 50);
+      const latestUrl = jiraUrl(host, `/issue/${encodeURIComponent(key)}/comment?startAt=${startAt}&maxResults=50`);
+      const latestRes = await httpClient.get(latestUrl, { headers }).catch(() => null);
+      if (latestRes && isSuccess(latestRes) && Array.isArray(latestRes.data?.comments)) {
+        comments = latestRes.data.comments;
+      }
     }
-    const comments = commentsResponse.data?.comments || [];
-    const relevant = comments.find((comment) => {
-      const author = comment.author || {};
+
+    const mentionComment = comments.find((comment) => {
       const body = typeof comment.body === 'string' ? comment.body : JSON.stringify(comment.body || '');
-      const mentionsMe = [identity.name, identity.accountId, identity.displayName].filter(Boolean).some((value) => body.includes(value));
-      const writtenBySomeoneElse = author.name !== identity.name && author.accountId !== identity.accountId;
-      return mentionsMe || writtenBySomeoneElse;
+      const author = comment.author || {};
+      const mentionsMe = [identity.name, identity.accountId, identity.displayName, identity.emailAddress]
+        .filter(Boolean)
+        .some((value) => body.toLowerCase().includes(value.toLowerCase()));
+      const isNotSelf = author.name !== identity.name && author.accountId !== identity.accountId;
+      return mentionsMe && isNotSelf;
+    });
+
+    const relevantComment = mentionComment || comments.find((comment) => {
+      const author = comment.author || {};
+      return author.name !== identity.name && author.accountId !== identity.accountId;
+    });
+
+    const isMention = Boolean(mentionComment);
+    const authorName = relevantComment?.author?.displayName || relevantComment?.author?.name || issue.fields?.reporter?.displayName || '';
+    const date = relevantComment?.updated || relevantComment?.created || issue.fields?.updated;
+    const commentId = relevantComment?.id;
+    const itemUrl = `https://${host}/browse/${issue.key}${commentId ? `?focusedCommentId=${commentId}#comment-${commentId}` : ''}`;
+
+    activityItems.push({
+      ...mapJiraIssue(issue),
+      source: 'Jira',
+      sourceType: 'jira',
+      author: authorName,
+      activityType: isMention ? 'Mentioned in Jira' : 'Commented in Jira',
+      activityAt: date,
+      url: itemUrl
     });
-    if (relevant) {
-      activityItems.push({
-        ...mapJiraIssue(issue),
-        activityType: [identity.name, identity.accountId, identity.displayName].filter(Boolean).some((value) => String(relevant.body || '').includes(value)) ? 'Mentioned' : 'Commented',
-        activityAt: relevant.updated || relevant.created || issue.fields?.updated
-      });
-    }
   }
 
   return {
     identity,
     dueToday: due.map((issue) => ({ ...mapJiraIssue(issue), url: issueUrl(host, issue.key) })),
-    activity: activityItems.map((item) => ({ ...item, url: issueUrl(host, item.key) }))
+    activity: activityItems
   };
 }
 
+async function loadConfluenceMentions(host, token) {
+  if (!host || !token) return [];
+  const authHeader = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+  const headers = { Accept: 'application/json', Authorization: authHeader };
+
+  const cqlQueries = [
+    'mention = currentUser() order by lastmodified desc',
+    'type in (page, blogpost, comment) and text ~ currentUser() order by lastmodified desc'
+  ];
+
+  let results = [];
+  for (const cql of cqlQueries) {
+    const url = `https://${host}/rest/api/content/search?cql=${encodeURIComponent(cql)}&expand=history.lastUpdated,version,space,container&limit=25`;
+    try {
+      const response = await httpClient.get(url, { headers });
+      if (isSuccess(response) && Array.isArray(response.data?.results) && response.data.results.length > 0) {
+        results = response.data.results;
+        break;
+      }
+    } catch {}
+  }
+
+  return results.map((item) => {
+    const spaceKey = item.space?.key || item.space?.name || 'Confluence';
+    const containerTitle = item.container?.title || '';
+    const itemTitle = item.title || (item.type === 'comment' ? 'Comment' : 'Page');
+    const displayTitle = containerTitle ? `${containerTitle} (${itemTitle})` : itemTitle;
+    const authorName = item.history?.lastUpdated?.by?.displayName || item.version?.by?.displayName || item.history?.createdBy?.displayName || '';
+    const date = item.history?.lastUpdated?.when || item.version?.when || item.history?.createdDate;
+    const webui = item._links?.webui || '';
+    const fullUrl = webui ? (webui.startsWith('http') ? webui : `https://${host}${webui}`) : `https://${host}/pages/viewpage.action?pageId=${item.id}`;
+
+    return {
+      id: `confluence-${item.id}`,
+      key: spaceKey,
+      title: displayTitle,
+      summary: displayTitle,
+      source: 'Confluence',
+      sourceType: 'confluence',
+      author: authorName,
+      activityType: 'Mentioned in Confluence',
+      activityAt: date ? new Date(date).toISOString() : null,
+      updated: date ? new Date(date).toISOString() : null,
+      url: fullUrl
+    };
+  });
+}
+
 async function loadAuthoredPullRequests(host, token) {
+  const authHeader = token.startsWith('Bearer ') ? token : `Bearer ${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}` } });
+  const response = await httpClient.get(url, { headers: { Accept: 'application/json', Authorization: authHeader } });
   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,
@@ -130,21 +230,35 @@ router.get('/', async (_req, res) => {
   }
   const jira = jiraHost(settings.domain);
   const bitbucket = bitbucketHost(settings.domain);
+  const confluence = confluenceHost(settings.domain);
+  const confluenceToken = settings.confluenceAccessToken || settings.jiraAccessToken;
+
   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 Author', () => loadAuthoredPullRequests(bitbucket, settings.bitbucketAccessToken))
+    requestSection('Bitbucket Author', () => loadAuthoredPullRequests(bitbucket, settings.bitbucketAccessToken)),
+    requestSection('Confluence Mentions', () => loadConfluenceMentions(confluence, confluenceToken))
   ]);
-  const [jiraData, authoredPrs] = sections;
+  const [jiraData, authoredPrs, confluenceData] = 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);
+
+  const allActivity = [
+    ...(jiraData.items?.activity || []),
+    ...(confluenceData.items || [])
+  ].sort((a, b) => {
+    const timeA = new Date(a.activityAt || a.updated || 0).getTime();
+    const timeB = new Date(b.activityAt || b.updated || 0).getTime();
+    return timeB - timeA;
+  });
+
   res.json({
     configured: true,
     missingTokens: [],
     fetchedAt: new Date().toISOString(),
     categories: {
-      activity: jiraData.items?.activity || [],
+      activity: allActivity,
       jiraDueToday: jiraData.items?.dueToday || [],
       assignedTodos: todos,
       authoredPrs: authoredPrs.items || []

package/server/routes/pr-conflicts.js

@@ -177,6 +177,60 @@ async function readFile({ host, projectKey, repositorySlug, commit, path }) {
 }
 
 router.post('/load', async (req, res) => {
+  const prUrl = String(req.body?.prUrl || '').trim();
+  if (prUrl.toLowerCase().includes('demo') || prUrl.toLowerCase().includes('mock')) {
+    return res.json({
+      conflicted: true,
+      pr: {
+        title: 'Demo: Feature User Management with Conflict',
+        sourceBranch: 'feature/user-management-v2',
+        targetBranch: 'main'
+      },
+      files: [
+        {
+          path: 'src/components/UserProfile.tsx',
+          sourceContent: `import React, { useState } from 'react';
+import { Card, Button } from '@acme/ui';
+
+// Source branch: contains upgraded configuration URL and new permissions check
+export const PROFILE_ENDPOINT_URL = 'https://api.internal.company.com/v2/users/profile';
+
+export function UserProfile({ userId }: { userId: string }) {
+  const [activeTab, setActiveTab] = useState('overview');
+  return (
+    <Card title="User Profile (V2)">
+      <p>Source branch implementation with updated permissions model and telemetry hooks.</p>
+      <Button onClick={() => setActiveTab('details')}>View Details</Button>
+    </Card>
+  );
+}`,
+          targetContent: `import React, { useState } from 'react';
+import { Card, Button } from '@acme/ui';
+
+// Target branch: contains legacy configuration URL
+export const PROFILE_ENDPOINT_URL = 'https://legacy-api.internal.company.com/v1/users/profile';
+
+export function UserProfile({ userId }: { userId: string }) {
+  const [tab, setTab] = useState('summary');
+  return (
+    <Card title="User Profile (Main)">
+      <p>Main branch implementation with legacy summary view.</p>
+      <Button onClick={() => setTab('summary')}>Summary</Button>
+    </Card>
+  );
+}`,
+          defaultChoice: 'source'
+        },
+        {
+          path: 'src/config/application-settings.json',
+          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'
+        }
+      ]
+    });
+  }
+
   const parsed = parsePrUrl(req.body?.prUrl);
   if (!parsed) return res.status(400).json({ error: 'Invalid Bitbucket Server Pull Request URL.' });
 

package/server/routes/pr-review.js

@@ -119,7 +119,8 @@ async function runAiReview({ aiApiHost, pr, files }) {
     'Focus on correctness, security, reliability, maintainability, and regressions introduced by the change.',
     'Report only actionable findings. For each finding include severity (critical, warning, or info), file, line if identifiable, title, explanation, and a concrete recommendation.',
     'If there are no actionable findings, use an empty findings array and say LGTM in the summary.',
-    'Return only valid JSON in this exact shape: {"summary":"...","findings":[{"severity":"warning","file":"path/to/file","line":12,"title":"...","explanation":"...","recommendation":"..."}]}',
+    'Format the "summary" field in rich, well-structured Markdown (with headings, bullet points, bold highlights, code blocks, etc.) providing an executive review overview, risk assessment, and recommendations.',
+    'Return only valid JSON in this exact shape: {"summary":"# PR Review Summary\\n\\n...Markdown content...","findings":[{"severity":"warning","file":"path/to/file","line":12,"title":"...","explanation":"...","recommendation":"..."}]}',
     'Do not invent files, code, or line numbers. Use null for line when a precise line cannot be identified.',
     '',
     `Pull request: ${pr.title || ''}`,
@@ -804,7 +805,19 @@ router.post('/check', async (req, res) => {
           status: 'completed',
           source: 'demo',
           reviewedFiles: aiFiles.length,
-          summary: 'Demo AI review: found several actionable quality and accessibility issues. Select a file to inspect the findings on the corresponding lines.',
+          summary: `### 📋 PR Review Executive Summary
+
+The pull request introduces feature updates across **${aiFiles.length} files**. The overall design is coherent, but several **critical quality**, **type-safety**, and **accessibility** concerns require attention before merge.
+
+#### 🚨 Key Action Items
+- **Type Safety**: Avoid using \`any\` in \`UserProfile.tsx\` (\`payload: any\`). Strongly type the interface.
+- **State Mutation**: In \`useUserStats.ts\`, \`state.list.push()\` directly mutates state. Use immutable state updates.
+- **Accessibility (a11y)**: In \`Dashboard.tsx\`, \`<div className="btn-wrapper" onClick={...}>\` is not keyboard accessible. Switch to \`<button>\` or an interactive component.
+- **Debugging Artifacts**: Remove \`debugger;\` and debug \`console.log\` statements in \`api.ts\`.
+
+#### 💡 Recommendations
+1. Validate external API payload shapes defensively at runtime.
+2. Ensure long configuration strings and secrets are loaded via environment variables rather than hardcoded URLs.`,
           content: 'Demo AI review: found several actionable quality and accessibility issues.',
           findings: demoAiFindings
         };