relay-ide 0.1.0

package/dist/test/pr-state.test.js

@@ -0,0 +1,407 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { derivePrAction, deriveSecondaryAction, getActionPrompt, getStatusCssVar, shouldUseDarkText, } from '../frontend/src/lib/pr-state.js';
+describe('derivePrAction', () => {
+    it('returns none when no commits ahead and no PR', () => {
+        const input = {
+            commitsAhead: 0,
+            prState: null,
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: null,
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'none');
+        assert.equal(action.color, 'none');
+        assert.equal(action.label, '');
+    });
+    it('returns create-pr when commits ahead but no PR', () => {
+        const input = {
+            commitsAhead: 3,
+            prState: null,
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: null,
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'create-pr');
+        assert.equal(action.color, 'accent');
+        assert.equal(action.label, 'Create PR');
+    });
+    it('returns ready-for-review for draft PR', () => {
+        const input = {
+            commitsAhead: 5,
+            prState: 'DRAFT',
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: null,
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'ready-for-review');
+        assert.equal(action.color, 'muted');
+        assert.equal(action.label, 'Ready for Review');
+    });
+    it('returns merge-pr for open PR with all CI passing (author default)', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'merge-pr');
+        assert.equal(action.color, 'success');
+        assert.equal(action.label, 'Merge');
+    });
+    it('returns merge-pr for open PR with no CI checks (author default)', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'merge-pr');
+        assert.equal(action.color, 'success');
+    });
+    it('returns fix-errors for open PR with failing CI', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 6,
+            ciFailing: 2,
+            ciPending: 0,
+            ciTotal: 8,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-errors');
+        assert.equal(action.color, 'error');
+        assert.equal(action.label, 'Fix Errors 2/8');
+    });
+    it('returns checks-running for open PR with pending CI', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 3,
+            ciFailing: 0,
+            ciPending: 2,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'checks-running');
+        assert.equal(action.color, 'warning');
+        assert.equal(action.label, 'Checks Running...');
+    });
+    it('prioritizes failing over pending CI', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 3,
+            ciFailing: 1,
+            ciPending: 1,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-errors');
+        assert.equal(action.label, 'Fix Errors 1/5');
+    });
+    it('returns archive-merged for merged PR', () => {
+        const input = {
+            commitsAhead: 0,
+            prState: 'MERGED',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: null,
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'archive-merged');
+        assert.equal(action.color, 'merged');
+        assert.equal(action.label, 'Archive');
+    });
+    it('returns archive-closed for closed PR', () => {
+        const input = {
+            commitsAhead: 0,
+            prState: 'CLOSED',
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: null,
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'archive-closed');
+        assert.equal(action.color, 'muted');
+        assert.equal(action.label, 'Archive');
+    });
+    it('returns fix-conflicts for open PR with CONFLICTING mergeable', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: 'CONFLICTING',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-conflicts');
+        assert.equal(action.color, 'error');
+        assert.equal(action.label, 'Fix Conflicts');
+    });
+    it('prioritizes fix-conflicts over fix-errors', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 0,
+            ciFailing: 3,
+            ciPending: 0,
+            ciTotal: 3,
+            mergeable: 'CONFLICTING',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-conflicts');
+    });
+    it('returns resolve-comments when unresolved comments > 0 and CI passing', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 3,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'resolve-comments');
+        assert.equal(action.color, 'accent');
+        assert.equal(action.label, 'Resolve Comments (3)');
+    });
+    // ── Role-aware tests ──
+    it('returns merge-pr for author when open + all clear', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+            role: 'author',
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'merge-pr');
+        assert.equal(action.color, 'success');
+        assert.equal(action.label, 'Merge');
+    });
+    it('returns review-pr with info color for reviewer when open + all clear', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+            role: 'reviewer',
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'review-pr');
+        assert.equal(action.color, 'info');
+        assert.equal(action.label, 'Review');
+    });
+    it('returns muted checks-running for reviewer when CI failing', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 3,
+            ciFailing: 2,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+            role: 'reviewer',
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'checks-running');
+        assert.equal(action.color, 'muted');
+        assert.equal(action.label, 'CI Failing');
+    });
+    it('returns none for reviewer on draft PR', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'DRAFT',
+            ciPassing: 0,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 0,
+            mergeable: null,
+            unresolvedCommentCount: 0,
+            role: 'reviewer',
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'none');
+    });
+    it('defaults to author behavior when role omitted', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        // Without role, defaults to author → merge-pr
+        assert.equal(action.type, 'merge-pr');
+    });
+});
+describe('getActionPrompt', () => {
+    it('returns prompt for create-pr', () => {
+        const prompt = getActionPrompt({ type: 'create-pr', color: 'accent', label: 'Create PR' }, { branchName: 'feat/my-feature' });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('feat/my-feature'));
+        assert.ok(prompt.includes('pull request'));
+    });
+    it('returns prompt for fix-errors', () => {
+        const prompt = getActionPrompt({ type: 'fix-errors', color: 'error', label: 'Fix Errors 2/8' }, { branchName: 'bugfix/auth' });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('bugfix/auth'));
+        assert.ok(prompt.includes('failing'));
+    });
+    it('returns prompt for review-pr', () => {
+        const prompt = getActionPrompt({ type: 'review-pr', color: 'success', label: 'Review PR' }, { branchName: 'main', prNumber: 42 });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('Review'));
+    });
+    it('returns prompt for fix-conflicts', () => {
+        const prompt = getActionPrompt({ type: 'fix-conflicts', color: 'error', label: 'Fix Conflicts' }, { branchName: 'feat/foo', baseBranch: 'main' });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('main'));
+        assert.ok(prompt.includes('conflict'));
+    });
+    it('returns prompt for resolve-comments', () => {
+        const prompt = getActionPrompt({
+            type: 'resolve-comments',
+            color: 'accent',
+            label: 'Resolve Comments (3)',
+        }, { branchName: 'feat/foo', prNumber: 7, unresolvedCommentCount: 3 });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('3'));
+        assert.ok(prompt.includes('#7'));
+    });
+    it('returns null for archive actions', () => {
+        assert.equal(getActionPrompt({ type: 'archive-merged', color: 'merged', label: 'Archive' }, { branchName: 'main' }), null);
+        assert.equal(getActionPrompt({ type: 'archive-closed', color: 'muted', label: 'Archive' }, { branchName: 'main' }), null);
+    });
+    it('returns null for none and checks-running', () => {
+        assert.equal(getActionPrompt({ type: 'none', color: 'none', label: '' }, { branchName: 'main' }), null);
+        assert.equal(getActionPrompt({
+            type: 'checks-running',
+            color: 'warning',
+            label: 'Checks Running...',
+        }, { branchName: 'main' }), null);
+    });
+    it('returns null for merge-pr (GitHub link action)', () => {
+        assert.equal(getActionPrompt({ type: 'merge-pr', color: 'success', label: 'Merge' }, { branchName: 'main' }), null);
+    });
+});
+describe('getStatusCssVar', () => {
+    it('maps all colors correctly', () => {
+        assert.equal(getStatusCssVar('accent'), 'var(--accent)');
+        assert.equal(getStatusCssVar('success'), 'var(--status-success)');
+        assert.equal(getStatusCssVar('error'), 'var(--status-error)');
+        assert.equal(getStatusCssVar('warning'), 'var(--status-warning)');
+        assert.equal(getStatusCssVar('merged'), 'var(--status-merged)');
+        assert.equal(getStatusCssVar('muted'), 'var(--border)');
+        assert.equal(getStatusCssVar('none'), 'transparent');
+        assert.equal(getStatusCssVar('info'), 'var(--status-info)');
+    });
+});
+describe('shouldUseDarkText', () => {
+    it('returns true for success and warning (light backgrounds)', () => {
+        assert.equal(shouldUseDarkText('success'), true);
+        assert.equal(shouldUseDarkText('warning'), true);
+    });
+    it('returns false for dark backgrounds', () => {
+        assert.equal(shouldUseDarkText('accent'), false);
+        assert.equal(shouldUseDarkText('error'), false);
+        assert.equal(shouldUseDarkText('merged'), false);
+        assert.equal(shouldUseDarkText('muted'), false);
+        assert.equal(shouldUseDarkText('none'), false);
+    });
+});
+describe('deriveSecondaryAction', () => {
+    it('returns review-pr secondary for author with unresolved comments', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 3,
+            role: 'author',
+        };
+        const primary = derivePrAction(input);
+        assert.equal(primary.type, 'resolve-comments');
+        const secondary = deriveSecondaryAction(primary, input);
+        assert.ok(secondary);
+        assert.equal(secondary.type, 'review-pr');
+        assert.equal(secondary.color, 'muted');
+    });
+    it('returns resolve-comments secondary for reviewer with unresolved comments', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5,
+            ciFailing: 0,
+            ciPending: 0,
+            ciTotal: 5,
+            mergeable: 'MERGEABLE',
+            unresolvedCommentCount: 3,
+            role: 'reviewer',
+        };
+        const primary = derivePrAction(input);
+        assert.equal(primary.type, 'review-pr');
+        assert.equal(primary.color, 'info');
+        const secondary = deriveSecondaryAction(primary, input);
+        assert.ok(secondary);
+        assert.equal(secondary.type, 'resolve-comments');
+        assert.equal(secondary.color, 'accent');
+    });
+});

package/dist/test/pr-status.test.js

@@ -0,0 +1,82 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { derivePrDotStatus, prGlyph } from '../frontend/src/lib/pr-status.js';
+function makePr(overrides) {
+    return {
+        number: 1,
+        title: 'Test',
+        url: '',
+        headRefName: '',
+        baseRefName: '',
+        state: 'OPEN',
+        author: 'user',
+        role: 'author',
+        updatedAt: '',
+        additions: 0,
+        deletions: 0,
+        reviewDecision: null,
+        mergeable: null,
+        isDraft: false,
+        ciStatus: null,
+        ...overrides,
+    };
+}
+describe('derivePrDotStatus', () => {
+    it('returns merged for MERGED state', () => {
+        assert.equal(derivePrDotStatus(makePr({ state: 'MERGED' })), 'merged');
+    });
+    it('returns closed for CLOSED state', () => {
+        assert.equal(derivePrDotStatus(makePr({ state: 'CLOSED' })), 'closed');
+    });
+    it('returns draft for isDraft PRs', () => {
+        assert.equal(derivePrDotStatus(makePr({ isDraft: true })), 'draft');
+    });
+    it('returns changes-requested when reviewDecision is CHANGES_REQUESTED', () => {
+        assert.equal(derivePrDotStatus(makePr({ reviewDecision: 'CHANGES_REQUESTED' })), 'changes-requested');
+    });
+    it('returns approved when reviewDecision is APPROVED', () => {
+        assert.equal(derivePrDotStatus(makePr({ reviewDecision: 'APPROVED' })), 'approved');
+    });
+    it('returns review-requested for reviewers', () => {
+        assert.equal(derivePrDotStatus(makePr({ role: 'reviewer' })), 'review-requested');
+    });
+    it('returns open for plain open PRs', () => {
+        assert.equal(derivePrDotStatus(makePr({})), 'open');
+    });
+    it('draft takes priority over changes-requested', () => {
+        assert.equal(derivePrDotStatus(makePr({ isDraft: true, reviewDecision: 'CHANGES_REQUESTED' })), 'draft');
+    });
+    it('merged takes priority over everything', () => {
+        assert.equal(derivePrDotStatus(makePr({
+            state: 'MERGED',
+            isDraft: true,
+            reviewDecision: 'APPROVED',
+            role: 'reviewer',
+        })), 'merged');
+    });
+});
+describe('prGlyph', () => {
+    it('maps each status to a unique character', () => {
+        const statuses = [
+            'draft',
+            'open',
+            'review-requested',
+            'changes-requested',
+            'approved',
+            'merged',
+            'closed',
+            'unknown',
+        ];
+        const chars = statuses.map((s) => prGlyph(s).char);
+        for (const c of chars) {
+            assert.ok(c.length > 0, 'each glyph should be non-empty');
+        }
+        // Ensure each status maps to a distinct glyph character
+        assert.equal(new Set(chars).size, statuses.length, 'all glyph characters should be unique');
+    });
+    it('approved is green checkmark', () => {
+        const g = prGlyph('approved');
+        assert.equal(g.char, '✓');
+        assert.equal(g.colorClass, 'pr-green');
+    });
+});