jira-pat 1.0.4 → 1.0.5

package/README.md

@@ -118,6 +118,41 @@ http://localhost:5173
 
 ---
 
+## Features
+
+### Dashboard & Search
+- View all Jira tickets assigned to you
+- Search tickets by keyword, issue key, or summary
+- Filter by project and status
+- Keyboard shortcut `/` to quickly access search
+
+### Issue Management
+- View full issue details in a side panel
+- Update issue status (transitions)
+- Reassign issues to other users
+- Add and remove labels
+- Update fix versions
+- Upload attachments (drag & drop)
+- **Edit issue summary** — click the pencil icon next to the title
+- **Edit issue description** — click the pencil icon next to the description header
+
+### Project Management
+- Create new issues (Task, Bug, Story, Epic, etc.)
+- View available projects
+- Browse project versions/releases
+
+### Comments
+- View and add comments on issues
+- Edit your own comments
+- **@mention team members** — type `@` in the comment box to search and mention project members
+
+### Real-time Updates
+- Optimistic UI updates for faster feedback
+- Loading states and error handling
+- Toast notifications for actions
+
+---
+
 ## License
 
 ISC

package/backend/__tests__/projects.test.js

@@ -265,5 +265,133 @@ describe('projects routes', () => {
             expect(response.body).toHaveProperty('details');
         });
     });
+
+    describe('GET /api/projects/:projectKey/members', () => {
+        it('should fetch project members', async () => {
+            const mockMembers = [
+                { 
+                    accountId: 'acc1', 
+                    displayName: 'John Doe', 
+                    emailAddress: 'john@example.com',
+                    avatarUrls: { '48x48': 'http://example.com/avatar1.png' }
+                },
+                { 
+                    accountId: 'acc2', 
+                    displayName: 'Jane Smith', 
+                    emailAddress: 'jane@example.com',
+                    avatarUrls: {}
+                }
+            ];
+            jiraService.getProjectMembers.mockResolvedValue(mockMembers);
+
+            const response = await request(server)
+                .get('/api/projects/ADW/members');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual(mockMembers);
+            expect(jiraService.getProjectMembers).toHaveBeenCalledWith('ADW', undefined);
+        });
+
+        it('should pass query parameter when searching', async () => {
+            const mockMembers = [
+                { accountId: 'acc1', displayName: 'John Doe', emailAddress: 'john@example.com', avatarUrls: {} }
+            ];
+            jiraService.getProjectMembers.mockResolvedValue(mockMembers);
+
+            const response = await request(server)
+                .get('/api/projects/ADW/members?query=john');
+
+            expect(response.status).toBe(200);
+            expect(jiraService.getProjectMembers).toHaveBeenCalledWith('ADW', 'john');
+        });
+
+        it('should return empty array when no members', async () => {
+            jiraService.getProjectMembers.mockResolvedValue([]);
+
+            const response = await request(server)
+                .get('/api/projects/EMPTY/members');
+
+            expect(response.status).toBe(200);
+            expect(response.body).toEqual([]);
+        });
+
+        it('should handle Jira API errors', async () => {
+            jiraService.getProjectMembers.mockRejectedValue(
+                new Error('Permission denied')
+            );
+
+            const response = await request(server)
+                .get('/api/projects/ADW/members');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch project members');
+            expect(response.body.details).toContain('Permission denied');
+        });
+
+        it('should handle authentication errors', async () => {
+            jiraService.getProjectMembers.mockRejectedValue(
+                new Error('Jira API Error: 401 - Unauthorized')
+            );
+
+            const response = await request(server)
+                .get('/api/projects/ADW/members');
+
+            expect(response.status).toBe(500);
+            expect(response.body.error).toBe('Failed to fetch project members');
+        });
+
+        it('should handle network errors', async () => {
+            jiraService.getProjectMembers.mockRejectedValue(
+                new Error('connect ECONNREFUSED')
+            );
+
+            const response = await request(server)
+                .get('/api/projects/ADW/members');
+
+            expect(response.status).toBe(500);
+            expect(response.body.details).toContain('ECONNREFUSED');
+        });
+
+        it('should return members with all properties', async () => {
+            const mockMembers = [
+                {
+                    accountId: 'acc123',
+                    displayName: 'Test User',
+                    emailAddress: 'test@company.com',
+                    avatarUrls: {
+                        '48x48': 'http://example.com/avatar.png',
+                        '32x32': 'http://example.com/avatar32.png'
+                    }
+                }
+            ];
+            jiraService.getProjectMembers.mockResolvedValue(mockMembers);
+
+            const response = await request(server)
+                .get('/api/projects/TEST/members');
+
+            expect(response.body[0]).toHaveProperty('accountId', 'acc123');
+            expect(response.body[0]).toHaveProperty('displayName', 'Test User');
+            expect(response.body[0]).toHaveProperty('emailAddress', 'test@company.com');
+            expect(response.body[0]).toHaveProperty('avatarUrls');
+        });
+
+        it('should pass project key to service', async () => {
+            jiraService.getProjectMembers.mockResolvedValue([]);
+
+            await request(server).get('/api/projects/PROJ123/members');
+
+            expect(jiraService.getProjectMembers).toHaveBeenCalledWith('PROJ123', undefined);
+        });
+
+        it('should handle empty query string', async () => {
+            jiraService.getProjectMembers.mockResolvedValue([]);
+
+            const response = await request(server)
+                .get('/api/projects/ADW/members?query=');
+
+            expect(response.status).toBe(200);
+            expect(jiraService.getProjectMembers).toHaveBeenCalledWith('ADW', '');
+        });
+    });
 });
 

package/backend/routes/issues.js

@@ -270,4 +270,38 @@ router.put('/:issueKey', mutationLimiter, async (req, res) => {
     }
 });
 
+// PUT /api/issues/:issueKey/summary
+router.put('/:issueKey/summary', mutationLimiter, async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { summary } = req.body;
+        if (!summary || typeof summary !== 'string') {
+            return res.status(400).json({ error: 'Summary is required' });
+        }
+        if (summary.length > 255) {
+            return res.status(400).json({ error: 'Summary must be under 255 characters' });
+        }
+        await jiraService.updateIssueSummary(req.params.issueKey, summary.trim());
+        res.json({ success: true });
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to update summary', details: error.message });
+    }
+});
+
+// PUT /api/issues/:issueKey/description
+router.put('/:issueKey/description', mutationLimiter, async (req, res) => {
+    const error = validateIssueKey(req.params.issueKey);
+    if (error) return res.status(400).json({ error });
+    
+    try {
+        const { description } = req.body;
+        await jiraService.updateIssueDescription(req.params.issueKey, description || '');
+        res.json({ success: true });
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to update description', details: error.message });
+    }
+});
+
 module.exports = router;

package/backend/routes/projects.js

@@ -32,4 +32,15 @@ router.get('/:projectKey/versions', async (req, res) => {
     }
 });
 
+// GET /api/projects/:projectKey/members
+router.get('/:projectKey/members', async (req, res) => {
+    try {
+        const { query } = req.query;
+        const members = await jiraService.getProjectMembers(req.params.projectKey, query);
+        res.json(members);
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to fetch project members', details: error.message });
+    }
+});
+
 module.exports = router;

package/backend/service/jiraService.js

@@ -549,6 +549,212 @@ const updateIssue = async (issueKey, fields) => {
     }
 };
 
+const updateIssueSummary = async (issueKey, summary) => {
+    try {
+        const client = getJiraClient();
+        await client.put(`/rest/api/3/issue/${issueKey}`, {
+            fields: { summary }
+        });
+        invalidateIssueCache(issueKey);
+        return { success: true };
+    } catch (error) {
+        console.error(`Error updating issue summary ${issueKey}:`, error.message);
+        throw error;
+    }
+};
+
+const convertHtmlToAdf = (html) => {
+    if (!html || !html.trim()) return null;
+    
+    const doc = {
+        type: 'doc',
+        version: 1,
+        content: []
+    };
+    
+    let content = [];
+    let remaining = html;
+    
+    const extractTag = (str) => {
+        const match = str.match(/^<([a-zA-Z][a-zA-Z0-9]*)/);
+        return match ? match[1].toLowerCase() : null;
+    };
+    
+    const extractClosingTag = (str, tag) => {
+        return new RegExp(`</${tag}>`, 'i');
+    };
+    
+    const extractAttribute = (tagStr, attrName) => {
+        const match = tagStr.match(new RegExp(`${attrName}=["']([^"']*)["']`, 'i'));
+        return match ? match[1] : null;
+    };
+    
+    const processElement = (htmlStr) => {
+        const tag = extractTag(htmlStr);
+        if (!tag) return null;
+        
+        const tagMatch = htmlStr.match(new RegExp(`<${tag}[^>]*>`, 'i'));
+        if (!tagMatch) return null;
+        
+        const fullTag = tagMatch[0];
+        const closingPattern = extractClosingTag(htmlStr, tag);
+        const closeMatch = htmlStr.match(closingPattern);
+        
+        let innerContent = '';
+        let afterContent = htmlStr;
+        
+        if (closeMatch) {
+            const closeIndex = htmlStr.indexOf(closeMatch[0]);
+            innerContent = htmlStr.substring(tagMatch[0].length, closeIndex);
+            afterContent = htmlStr.substring(closeIndex + closeMatch[0].length);
+        }
+        
+        const cleanText = (text) => text.replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+        
+        switch (tag) {
+            case 'p':
+            case 'div':
+                if (innerContent.trim()) {
+                    return {
+                        node: { type: 'paragraph', content: [{ type: 'text', text: cleanText(innerContent) }] },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+                
+            case 'strong':
+            case 'b':
+                if (innerContent.trim()) {
+                    return {
+                        node: { type: 'text', marks: [{ type: 'bold' }], text: cleanText(innerContent) },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+                
+            case 'em':
+            case 'i':
+                if (innerContent.trim()) {
+                    return {
+                        node: { type: 'text', marks: [{ type: 'italic' }], text: cleanText(innerContent) },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+                
+            case 'a':
+                const href = extractAttribute(fullTag, 'href');
+                if (href && innerContent.trim()) {
+                    return {
+                        node: { type: 'text', marks: [{ type: 'link', attrs: { href } }], text: cleanText(innerContent) },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+                
+            case 'img':
+                const src = extractAttribute(fullTag, 'src');
+                if (src) {
+                    return {
+                        node: { type: 'image', attrs: { src } },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+                
+            case 'h1':
+            case 'h2':
+            case 'h3':
+            case 'h4':
+            case 'h5':
+            case 'h6':
+                const level = parseInt(tag.charAt(1));
+                if (innerContent.trim()) {
+                    return {
+                        node: { type: 'heading', attrs: { level }, content: [{ type: 'text', text: cleanText(innerContent) }] },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+                
+            case 'br':
+                return {
+                    node: { type: 'text', text: '\n' },
+                    remaining: afterContent
+                };
+                
+            default:
+                if (innerContent.trim()) {
+                    return {
+                        node: { type: 'paragraph', content: [{ type: 'text', text: cleanText(innerContent) }] },
+                        remaining: afterContent
+                    };
+                }
+                return { node: null, remaining: afterContent };
+        }
+    };
+    
+    while (remaining.trim()) {
+        const ltIndex = remaining.indexOf('<');
+        
+        if (ltIndex === -1) {
+            const text = remaining.trim();
+            if (text) {
+                content.push({ type: 'paragraph', content: [{ type: 'text', text }] });
+            }
+            break;
+        }
+        
+        if (ltIndex > 0) {
+            const text = remaining.substring(0, ltIndex).trim();
+            if (text) {
+                content.push({ type: 'paragraph', content: [{ type: 'text', text }] });
+            }
+        }
+        
+        const result = processElement(remaining.substring(ltIndex));
+        if (result && result.node) {
+            content.push(result.node);
+        }
+        
+        if (result && result.remaining) {
+            remaining = result.remaining;
+        } else {
+            break;
+        }
+    }
+    
+    if (content.length === 0) {
+        content.push({
+            type: 'paragraph',
+            content: [{ type: 'text', text: '' }]
+        });
+    }
+    
+    doc.content = content;
+    return doc;
+};
+
+const updateIssueDescription = async (issueKey, description) => {
+    try {
+        const client = getJiraClient();
+        
+        let descADF = null;
+        if (description && description.trim()) {
+            descADF = convertHtmlToAdf(description);
+        }
+        
+        await client.put(`/rest/api/3/issue/${issueKey}`, {
+            fields: { description: descADF }
+        });
+        invalidateIssueCache(issueKey);
+        return { success: true };
+    } catch (error) {
+        console.error(`Error updating issue description ${issueKey}:`, error.message);
+        throw error;
+    }
+};
+
 const searchLabels = async (query) => {
     try {
         const client = getJiraClient();
@@ -558,7 +764,6 @@ const searchLabels = async (query) => {
                 fieldValue: query || ''
             }
         });
-        // response.data.results is an array of { displayName, value }
         return (response.data.results || []).map(item => item.value);
     } catch (error) {
         console.error('Error searching labels:', error.message);
@@ -566,6 +771,72 @@ const searchLabels = async (query) => {
     }
 };
 
+const getProjectMembers = async (projectKey, query) => {
+    const cacheKey = `project_members_${projectKey}_${query || 'all'}`;
+    const cachedMembers = cache.get(cacheKey);
+    
+    if (cachedMembers) {
+        console.log(`Returning cached project members for ${projectKey}`);
+        return cachedMembers;
+    }
+
+    try {
+        const client = getJiraClient();
+        console.log(`Fetching project members for ${projectKey}${query ? ` (query: ${query})` : ''}`);
+        
+        const seen = new Map();
+        
+        const issuesResponse = await client.get('/rest/api/3/search/jql', {
+            params: {
+                jql: `project = "${projectKey}" ORDER BY updated DESC`,
+                maxResults: 100,
+                fields: 'assignee,reporter'
+            }
+        });
+        
+        for (const issue of (issuesResponse.data.issues || [])) {
+            const assignee = issue.fields?.assignee;
+            if (assignee && assignee.accountId && !seen.has(assignee.accountId)) {
+                seen.set(assignee.accountId, {
+                    accountId: assignee.accountId,
+                    displayName: assignee.displayName,
+                    emailAddress: assignee.emailAddress || '',
+                    avatarUrls: assignee.avatarUrls || {}
+                });
+            }
+            
+            const reporter = issue.fields?.reporter;
+            if (reporter && reporter.accountId && !seen.has(reporter.accountId)) {
+                seen.set(reporter.accountId, {
+                    accountId: reporter.accountId,
+                    displayName: reporter.displayName,
+                    emailAddress: reporter.emailAddress || '',
+                    avatarUrls: reporter.avatarUrls || {}
+                });
+            }
+        }
+        
+        let members = Array.from(seen.values());
+        
+        if (query && query.trim()) {
+            const searchTerm = query.toLowerCase();
+            members = members.filter(m => 
+                m.displayName.toLowerCase().includes(searchTerm) ||
+                (m.emailAddress && m.emailAddress.toLowerCase().includes(searchTerm))
+            );
+        }
+        
+        members.sort((a, b) => a.displayName.localeCompare(b.displayName));
+        
+        cache.set(cacheKey, members, 3600);
+
+        return members;
+    } catch (error) {
+        console.error(`Error fetching project members for ${projectKey}:`, error.message);
+        throw error;
+    }
+};
+
 module.exports = {
     searchIssues,
     getIssueDetail,
@@ -582,8 +853,11 @@ module.exports = {
     getIssueTypes,
     getProjectVersions,
     updateIssue,
+    updateIssueSummary,
+    updateIssueDescription,
     searchLabels,
     createIssue,
     downloadAttachment,
-    adfToText
+    adfToText,
+    getProjectMembers
 };