buddy-workbench 0.1.75 → 0.1.77

package/package.json

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

package/server/routes/jira-filters.js

@@ -230,10 +230,199 @@ 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}` };
+  const meResponse = await httpClient.get(`https://${jiraHost}/rest/api/2/myself`, { headers });
+  if (meResponse.status < 200 || meResponse.status >= 300) return {};
+  const me = meResponse.data || {};
+  return { accountId: me.accountId || '', name: me.name || '', displayName: me.displayName || '', emailAddress: me.emailAddress || '' };
+}
+
 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 jql = 'updated >= -60d AND (comment ~ currentUser() OR assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC';
+    const searchUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent(jql)}&maxResults=30&fields=summary,priority,status,updated,assignee,reporter`;
+    const response = await httpClient.get(searchUrl, { headers });
+    if (response.status < 200 || response.status >= 300) return res.json([]);
+
+    const issues = response.data?.issues || [];
+    const results = [];
+
+    for (const issue of issues.slice(0, 25)) {
+      const key = issue.key;
+      const fields = issue.fields || {};
+      const commentsUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(key)}/comment?orderBy=-updated&maxResults=10`;
+      const commentsResponse = await httpClient.get(commentsUrl, { headers }).catch(() => null);
+      const comments = commentsResponse?.status === 200 ? (commentsResponse.data?.comments || []) : [];
+
+      if (comments.length > 0) {
+        const myComments = comments.filter((c) => {
+          const author = c.author || {};
+          return (
+            (identity.name && author.name === identity.name) ||
+            (identity.accountId && author.accountId === identity.accountId) ||
+            (identity.displayName && author.displayName === identity.displayName)
+          );
+        });
+
+        if (myComments.length > 0) {
+          const latestMyComment = myComments[0];
+          const body = typeof latestMyComment.body === 'string' ? latestMyComment.body : JSON.stringify(latestMyComment.body || '');
+          const commentSnippet = body.slice(0, 140).replace(/\r?\n+/g, ' ');
+          const commentId = latestMyComment.id;
+
+          results.push({
+            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}` : ''}`
+          });
+        }
+      }
+    }
+
+    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);
+    let issues = [];
+    try {
+      const searchUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent('text ~ currentUser() ORDER BY updated DESC')}&maxResults=30&fields=summary,priority,status,updated,assignee,reporter`;
+      const response = await httpClient.get(searchUrl, { headers });
+      if (response.status === 200) issues = response.data?.issues || [];
+    } catch {}
+
+    if (issues.length === 0) {
+      try {
+        const fallbackUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent('updated >= -30d AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC')}&maxResults=30&fields=summary,priority,status,updated,assignee,reporter`;
+        const response = await httpClient.get(fallbackUrl, { headers });
+        if (response.status === 200) issues = response.data?.issues || [];
+      } catch {}
+    }
+
+    const results = [];
+    for (const issue of issues.slice(0, 25)) {
+      const key = issue.key;
+      const fields = issue.fields || {};
+      const commentsUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(key)}/comment?orderBy=-updated&maxResults=10`;
+      const commentsResponse = await httpClient.get(commentsUrl, { headers }).catch(() => null);
+      const comments = commentsResponse?.status === 200 ? (commentsResponse.data?.comments || []) : [];
+
+      const mentionComment = comments.find((c) => {
+        const body = typeof c.body === 'string' ? c.body : JSON.stringify(c.body || '');
+        const author = c.author || {};
+        const isNotMe = author.name !== identity.name && author.accountId !== identity.accountId;
+        const mentionsMe = [identity.name, identity.accountId, identity.displayName, identity.emailAddress]
+          .filter(Boolean)
+          .some((val) => body.toLowerCase().includes(val.toLowerCase()));
+        return mentionsMe && isNotMe;
+      });
+
+      if (mentionComment) {
+        const author = mentionComment.author?.displayName || mentionComment.author?.name || '';
+        const body = typeof mentionComment.body === 'string' ? mentionComment.body : JSON.stringify(mentionComment.body || '');
+        const snippet = body.slice(0, 140).replace(/\r?\n+/g, ' ');
+        const commentId = mentionComment.id;
+
+        results.push({
+          id: `${issue.id}-${commentId || 'm'}`,
+          key,
+          summary: fields.summary || key,
+          priority: fields.priority?.name || '',
+          status: fields.status?.name || '',
+          mentionedBy: author,
+          mentionSnippet: snippet,
+          mentionedAt: mentionComment.updated || mentionComment.created || fields.updated,
+          url: `https://${jiraHost}/browse/${key}${commentId ? `?focusedCommentId=${commentId}#comment-${commentId}` : ''}`
+        });
+      }
+    }
+
+    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 {
+    let issues = [];
+    try {
+      const jql = 'updatedBy(currentUser()) ORDER BY updated DESC';
+      const searchUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent(jql)}&maxResults=40&fields=summary,priority,status,updated,duedate,assignee,reporter`;
+      const response = await httpClient.get(searchUrl, { headers });
+      if (response.status === 200) issues = response.data?.issues || [];
+    } catch {}
+
+    if (issues.length === 0) {
+      try {
+        const fallbackJql = '(assignee = currentUser() OR reporter = currentUser()) AND updated >= -30d ORDER BY updated DESC';
+        const searchUrl = `https://${jiraHost}/rest/api/2/search?jql=${encodeURIComponent(fallbackJql)}&maxResults=40&fields=summary,priority,status,updated,duedate,assignee,reporter`;
+        const response = await httpClient.get(searchUrl, { headers });
+        if (response.status === 200) issues = response.data?.issues || [];
+      } catch {}
+    }
+
+    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,128 @@ 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 = [];
+  try {
+    activityIssues = await searchJira(host, token, 'text ~ currentUser() ORDER BY updated DESC', fields, 30);
+  } catch {
+    try {
+      activityIssues = await searchJira(host, token, 'updated >= -30d AND (assignee = currentUser() OR reporter = currentUser() OR watcher = currentUser()) ORDER BY updated DESC', fields, 30);
+    } catch {
+      activityIssues = [];
+    }
+  }
 
   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 comments = commentsResponse.data?.comments || [];
-    const relevant = comments.find((comment) => {
-      const author = comment.author || {};
+    const commentsResponse = await httpClient.get(commentsUrl, { headers }).catch(() => null);
+    const comments = commentsResponse && isSuccess(commentsResponse) ? (commentsResponse.data?.comments || []) : [];
+
+    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 +210,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

@@ -118,13 +118,62 @@ function pathOf(change) {
   return change?.path?.toString || change?.path?.name || change?.path || change?.src?.toString || '';
 }
 
+function extractTextFromContent(data) {
+  if (data === null || data === undefined) return '';
+  if (typeof data === 'object') {
+    if (Array.isArray(data.lines)) {
+      return data.lines.map((line) => {
+        if (typeof line === 'string') return line;
+        if (line && typeof line.text === 'string') return line.text;
+        return typeof line === 'object' && line !== null ? (line.text ?? JSON.stringify(line)) : String(line ?? '');
+      }).join('\n');
+    }
+    if (typeof data.text === 'string') return data.text;
+    return JSON.stringify(data);
+  }
+  if (typeof data === 'string') {
+    const trimmed = data.trim();
+    if (trimmed.startsWith('{') && (trimmed.includes('"lines"') || trimmed.includes('"text"'))) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed?.lines)) {
+          return parsed.lines.map((line) => {
+            if (typeof line === 'string') return line;
+            if (line && typeof line.text === 'string') return line.text;
+            return typeof line === 'object' && line !== null ? (line.text ?? JSON.stringify(line)) : String(line ?? '');
+          }).join('\n');
+        }
+        if (typeof parsed?.text === 'string') return parsed.text;
+      } catch {}
+    }
+    return data;
+  }
+  return String(data);
+}
+
 async function readFile({ host, projectKey, repositorySlug, commit, path }) {
   if (!commit || !path) return '';
-  const url = `https://${host}/rest/api/latest/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repositorySlug)}/browse/${path.split('/').map(encodeURIComponent).join('/')}?at=${encodeURIComponent(commit)}&raw=true`;
-  const response = await client.get(url, { headers: authHeaders(), responseType: 'text' });
-  if (response.status < 200 || response.status >= 300) return '';
-  if (typeof response.data === 'string') return response.data;
-  return (response.data.lines || []).map((line) => line.text ?? line).join('\n');
+  const encodedPath = path.split('/').map(encodeURIComponent).join('/');
+
+  // 1. Try raw endpoint first (returns pure plaintext)
+  const rawUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repositorySlug)}/raw/${encodedPath}?at=${encodeURIComponent(commit)}`;
+  try {
+    const rawRes = await client.get(rawUrl, { headers: authHeaders(), responseType: 'text' });
+    if (rawRes.status >= 200 && rawRes.status < 300 && rawRes.data !== undefined) {
+      return extractTextFromContent(rawRes.data);
+    }
+  } catch {}
+
+  // 2. Fallback to browse endpoint with limit=10000
+  const browseUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(projectKey)}/repos/${encodeURIComponent(repositorySlug)}/browse/${encodedPath}?at=${encodeURIComponent(commit)}&limit=10000`;
+  try {
+    const response = await client.get(browseUrl, { headers: authHeaders(), responseType: 'text' });
+    if (response.status >= 200 && response.status < 300 && response.data !== undefined) {
+      return extractTextFromContent(response.data);
+    }
+  } catch {}
+
+  return '';
 }
 
 router.post('/load', async (req, res) => {