tlc-claude-code 1.4.2 → 1.4.5

package/dashboard/dist/api/tasks-api.test.js

@@ -0,0 +1,383 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, it, expect } from 'vitest';
+import { getTasks, parseTasksFromPlan } from './tasks-api.js';
+// Helper to create a mock Dirent
+function createDirent(name, isDir) {
+    return {
+        name,
+        isDirectory: () => isDir,
+        isFile: () => !isDir,
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isFIFO: () => false,
+        isSocket: () => false,
+        isSymbolicLink: () => false,
+        parentPath: '',
+        path: '',
+    };
+}
+// Helper to create a mock file system
+function createMockFs(config) {
+    return {
+        existsSync: (path) => config.existingPaths?.has(path) ?? false,
+        readdir: async (path) => {
+            if (config.readdirError)
+                throw config.readdirError;
+            return config.dirEntries?.get(path) ?? [];
+        },
+        readFile: async (path) => {
+            if (config.readFileError)
+                throw config.readFileError;
+            const content = config.fileContents?.get(path);
+            if (content === undefined)
+                throw new Error(`File not found: ${path}`);
+            return content;
+        },
+    };
+}
+describe('tasks-api', () => {
+    describe('getTasks', () => {
+        it('returns empty array when no PLAN.md exists', async () => {
+            const mockFs = createMockFs({
+                existingPaths: new Set(), // No paths exist
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toEqual([]);
+        });
+        it('returns empty array when phases directory is empty', async () => {
+            const mockFs = createMockFs({
+                existingPaths: new Set(['/project/.planning/phases']),
+                dirEntries: new Map([['/project/.planning/phases', []]]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toEqual([]);
+        });
+        it('parses tasks from PLAN.md correctly', async () => {
+            const planContent = `# Phase 39: Fix API
+
+### Task 1: Create tasks-api.js [ ]
+
+Description here.
+
+### Task 2: Add tests [ ]
+
+More description.
+`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/39-fix-api/39-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('39-fix-api', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/39-fix-api/39-PLAN.md', planContent],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0]).toEqual({
+                id: '39-1',
+                title: 'Create tasks-api.js',
+                status: 'pending',
+                owner: null,
+                phase: 39,
+            });
+            expect(tasks[1]).toEqual({
+                id: '39-2',
+                title: 'Add tests',
+                status: 'pending',
+                owner: null,
+                phase: 39,
+            });
+        });
+        it('extracts status from markers', async () => {
+            const planContent = `# Phase 1: Setup
+
+### Task 1: Pending task [ ]
+
+### Task 2: In progress task [>]
+
+### Task 3: Completed task [x]
+`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/01-setup/01-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('01-setup', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/01-setup/01-PLAN.md', planContent],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toHaveLength(3);
+            expect(tasks[0].status).toBe('pending');
+            expect(tasks[1].status).toBe('in_progress');
+            expect(tasks[2].status).toBe('completed');
+        });
+        it('extracts owner from @username', async () => {
+            const planContent = `# Phase 5: Auth
+
+### Task 1: No owner [ ]
+
+### Task 2: Has owner [>@alice]
+
+### Task 3: Completed with owner [x@bob]
+`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/05-auth/05-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('05-auth', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/05-auth/05-PLAN.md', planContent],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toHaveLength(3);
+            expect(tasks[0].owner).toBeNull();
+            expect(tasks[1].owner).toBe('alice');
+            expect(tasks[2].owner).toBe('bob');
+        });
+        it('handles multiple phases (scans all *-PLAN.md files)', async () => {
+            const phase1Content = `### Task 1: Init [ ]`;
+            const phase2Content = `### Task 1: Build API [>@alice]
+### Task 2: Add routes [x]`;
+            const phase3Content = `### Task 1: Unit tests [ ]`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/01-setup/01-PLAN.md',
+                    '/project/.planning/phases/02-core/02-PLAN.md',
+                    '/project/.planning/phases/03-testing/03-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [
+                            createDirent('01-setup', true),
+                            createDirent('02-core', true),
+                            createDirent('03-testing', true),
+                        ]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/01-setup/01-PLAN.md', phase1Content],
+                    ['/project/.planning/phases/02-core/02-PLAN.md', phase2Content],
+                    ['/project/.planning/phases/03-testing/03-PLAN.md', phase3Content],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toHaveLength(4);
+            // Check that tasks from different phases have correct phase numbers
+            const phase1Tasks = tasks.filter((t) => t.phase === 1);
+            const phase2Tasks = tasks.filter((t) => t.phase === 2);
+            const phase3Tasks = tasks.filter((t) => t.phase === 3);
+            expect(phase1Tasks).toHaveLength(1);
+            expect(phase2Tasks).toHaveLength(2);
+            expect(phase3Tasks).toHaveLength(1);
+            // Verify task IDs include phase
+            expect(tasks.map((t) => t.id).sort()).toEqual(['1-1', '2-1', '2-2', '3-1']);
+        });
+        it('handles malformed PLAN.md gracefully', async () => {
+            const planContent = `# Some random content
+
+Not a task at all
+
+### Task without status marker
+
+### Task 1: Valid task [ ]
+
+### Task: Missing number [ ]
+
+### Task 2 No colon [x]
+
+Random text between
+
+### Task 3: Another valid [>@dev]
+`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/10-broken/10-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('10-broken', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/10-broken/10-PLAN.md', planContent],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            // Should only parse the valid tasks
+            expect(tasks).toHaveLength(2);
+            expect(tasks[0]).toEqual({
+                id: '10-1',
+                title: 'Valid task',
+                status: 'pending',
+                owner: null,
+                phase: 10,
+            });
+            expect(tasks[1]).toEqual({
+                id: '10-3',
+                title: 'Another valid',
+                status: 'in_progress',
+                owner: 'dev',
+                phase: 10,
+            });
+        });
+        it('handles tasks without explicit markers (defaults to pending)', async () => {
+            const planContent = `# Phase 7: Feature
+
+### Task 1: Has marker [x]
+
+### Task 2: No marker
+`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/07-feature/07-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('07-feature', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/07-feature/07-PLAN.md', planContent],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            // Task 2 without marker should not be parsed as a task
+            // Only properly formatted tasks with markers are valid
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].title).toBe('Has marker');
+        });
+        it('handles empty PLAN.md files', async () => {
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/99-empty/99-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('99-empty', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/99-empty/99-PLAN.md', ''],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toEqual([]);
+        });
+        it('ignores non-PLAN.md files in phases directory', async () => {
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/01-setup/01-PLAN.md',
+                    // These should not be read (different files, not PLAN.md)
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('01-setup', true)]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/01-setup/01-PLAN.md', `### Task 1: Real task [ ]`],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].title).toBe('Real task');
+        });
+        it('sorts tasks by phase number then task number', async () => {
+            const phase10Content = `### Task 2: Ten-Two [ ]
+### Task 1: Ten-One [ ]`;
+            const phase2Content = `### Task 1: Two-One [ ]`;
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/10-later/10-PLAN.md',
+                    '/project/.planning/phases/02-early/02-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [
+                            createDirent('10-later', true),
+                            createDirent('02-early', true),
+                        ]],
+                ]),
+                fileContents: new Map([
+                    ['/project/.planning/phases/10-later/10-PLAN.md', phase10Content],
+                    ['/project/.planning/phases/02-early/02-PLAN.md', phase2Content],
+                ]),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks.map((t) => t.id)).toEqual(['2-1', '10-1', '10-2']);
+        });
+        it('handles readdir errors gracefully', async () => {
+            const mockFs = createMockFs({
+                existingPaths: new Set(['/project/.planning/phases']),
+                readdirError: new Error('Permission denied'),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toEqual([]);
+        });
+        it('handles readFile errors gracefully', async () => {
+            const mockFs = createMockFs({
+                existingPaths: new Set([
+                    '/project/.planning/phases',
+                    '/project/.planning/phases/01-setup/01-PLAN.md',
+                ]),
+                dirEntries: new Map([
+                    ['/project/.planning/phases', [createDirent('01-setup', true)]],
+                ]),
+                readFileError: new Error('File not readable'),
+            });
+            const tasks = await getTasks('/project', mockFs);
+            expect(tasks).toEqual([]);
+        });
+    });
+    describe('parseTasksFromPlan', () => {
+        it('returns empty array for empty content', () => {
+            expect(parseTasksFromPlan('', 1)).toEqual([]);
+        });
+        it('parses valid task format', () => {
+            const content = `### Task 1: My task [ ]`;
+            const tasks = parseTasksFromPlan(content, 5);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0]).toEqual({
+                id: '5-1',
+                title: 'My task',
+                status: 'pending',
+                owner: null,
+                phase: 5,
+            });
+        });
+        it('handles all status markers', () => {
+            const content = `### Task 1: Pending [ ]
+### Task 2: In Progress [>]
+### Task 3: Completed [x]`;
+            const tasks = parseTasksFromPlan(content, 1);
+            expect(tasks[0].status).toBe('pending');
+            expect(tasks[1].status).toBe('in_progress');
+            expect(tasks[2].status).toBe('completed');
+        });
+        it('extracts owner from status marker', () => {
+            const content = `### Task 1: With owner [>@alice]
+### Task 2: Completed owner [x@bob]`;
+            const tasks = parseTasksFromPlan(content, 1);
+            expect(tasks[0].owner).toBe('alice');
+            expect(tasks[1].owner).toBe('bob');
+        });
+        it('ignores malformed task lines', () => {
+            const content = `### Task: No number [ ]
+### Task 1 No colon [ ]
+### Task 1: No marker
+### Task 1: Valid [ ]`;
+            const tasks = parseTasksFromPlan(content, 1);
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].title).toBe('Valid');
+        });
+    });
+});

package/dashboard/dist/components/BugsPane.d.ts

@@ -0,0 +1,20 @@
+export type BugSeverity = 'low' | 'medium' | 'high' | 'critical';
+export type BugStatus = 'open' | 'in_progress' | 'fixed' | 'verified' | 'closed' | 'wontfix';
+export interface Bug {
+    id: string;
+    title: string;
+    description: string;
+    status: BugStatus;
+    priority: BugSeverity;
+    reporter?: string;
+    assignee?: string;
+    issueId?: string;
+    createdAt?: string;
+    labels?: string[];
+}
+export interface BugsPaneProps {
+    isActive?: boolean;
+    isTTY?: boolean;
+    apiBaseUrl?: string;
+}
+export declare function BugsPane({ isActive, isTTY, apiBaseUrl, }: BugsPaneProps): import("react/jsx-runtime").JSX.Element;

package/dashboard/dist/components/BugsPane.js

@@ -0,0 +1,210 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useMemo } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Spinner from 'ink-spinner';
+// Severity color mapping
+const severityColors = {
+    critical: 'red',
+    high: 'yellow',
+    medium: 'blue',
+    low: 'gray',
+};
+// Status color mapping
+const statusColors = {
+    open: 'red',
+    in_progress: 'yellow',
+    fixed: 'green',
+    verified: 'cyan',
+    closed: 'gray',
+    wontfix: 'magenta',
+};
+export function BugsPane({ isActive = true, isTTY = true, apiBaseUrl = 'http://localhost:5001', }) {
+    // Form state
+    const [title, setTitle] = useState('');
+    const [description, setDescription] = useState('');
+    const [severity, setSeverity] = useState('medium');
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [submitMessage, setSubmitMessage] = useState(null);
+    // List state
+    const [bugs, setBugs] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    const [loadError, setLoadError] = useState(null);
+    const [filter, setFilter] = useState('all');
+    // Navigation state
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [activeSection, setActiveSection] = useState('form');
+    const [formField, setFormField] = useState('title');
+    // Fetch bugs on mount and after submission
+    const fetchBugs = async () => {
+        setIsLoading(true);
+        setLoadError(null);
+        try {
+            const response = await fetch(`${apiBaseUrl}/api/bugs`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            setBugs(data);
+        }
+        catch (err) {
+            setLoadError(err instanceof Error ? err.message : 'Failed to fetch bugs');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        fetchBugs();
+    }, [apiBaseUrl]);
+    // Filter bugs
+    const filteredBugs = useMemo(() => {
+        switch (filter) {
+            case 'open':
+                return bugs.filter(b => b.status === 'open' || b.status === 'in_progress');
+            case 'closed':
+                return bugs.filter(b => b.status === 'closed' || b.status === 'fixed' || b.status === 'verified' || b.status === 'wontfix');
+            default:
+                return bugs;
+        }
+    }, [bugs, filter]);
+    // Submit bug
+    const submitBug = async () => {
+        if (!title.trim()) {
+            setSubmitMessage({ type: 'error', text: 'Title is required' });
+            return;
+        }
+        setIsSubmitting(true);
+        setSubmitMessage(null);
+        try {
+            const response = await fetch(`${apiBaseUrl}/api/bug`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    description: `${title}\n\n${description}`.trim(),
+                    severity,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error || `HTTP ${response.status}`);
+            }
+            // Clear form and refresh list
+            setTitle('');
+            setDescription('');
+            setSeverity('medium');
+            setSubmitMessage({ type: 'success', text: 'Bug submitted successfully!' });
+            await fetchBugs();
+            // Clear success message after 3 seconds
+            setTimeout(() => setSubmitMessage(null), 3000);
+        }
+        catch (err) {
+            setSubmitMessage({
+                type: 'error',
+                text: err instanceof Error ? err.message : 'Failed to submit bug',
+            });
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    };
+    // Keyboard handling
+    useInput((input, key) => {
+        if (!isActive)
+            return;
+        // Tab to switch sections
+        if (key.tab) {
+            if (activeSection === 'form') {
+                setActiveSection('filters');
+            }
+            else if (activeSection === 'filters') {
+                setActiveSection('list');
+            }
+            else {
+                setActiveSection('form');
+            }
+            return;
+        }
+        // Section-specific handling
+        if (activeSection === 'form') {
+            // Navigate form fields with up/down
+            if (key.upArrow) {
+                if (formField === 'description')
+                    setFormField('title');
+                else if (formField === 'severity')
+                    setFormField('description');
+            }
+            else if (key.downArrow) {
+                if (formField === 'title')
+                    setFormField('description');
+                else if (formField === 'description')
+                    setFormField('severity');
+            }
+            // Severity selection with left/right
+            if (formField === 'severity') {
+                const severities = ['low', 'medium', 'high', 'critical'];
+                const currentIndex = severities.indexOf(severity);
+                if (key.leftArrow && currentIndex > 0) {
+                    setSeverity(severities[currentIndex - 1]);
+                }
+                else if (key.rightArrow && currentIndex < severities.length - 1) {
+                    setSeverity(severities[currentIndex + 1]);
+                }
+            }
+            // Enter to submit when on severity
+            if (key.return && formField === 'severity') {
+                submitBug();
+            }
+            // Type text in title/description fields
+            if (formField === 'title' || formField === 'description') {
+                if (key.backspace || key.delete) {
+                    if (formField === 'title') {
+                        setTitle(prev => prev.slice(0, -1));
+                    }
+                    else {
+                        setDescription(prev => prev.slice(0, -1));
+                    }
+                }
+                else if (input && !key.ctrl && !key.meta && input.length === 1) {
+                    if (formField === 'title') {
+                        setTitle(prev => prev + input);
+                    }
+                    else {
+                        setDescription(prev => prev + input);
+                    }
+                }
+            }
+        }
+        else if (activeSection === 'filters') {
+            // Filter selection with 1, 2, 3 or arrow keys
+            if (input === '1' || (key.leftArrow && filter !== 'all')) {
+                setFilter('all');
+            }
+            else if (input === '2' || (key.rightArrow && filter === 'all')) {
+                setFilter('open');
+            }
+            else if (input === '3' || (key.rightArrow && filter === 'open')) {
+                setFilter('closed');
+            }
+        }
+        else if (activeSection === 'list') {
+            // Navigate bug list
+            if (key.downArrow || input === 'j') {
+                setSelectedIndex(prev => Math.min(prev + 1, filteredBugs.length - 1));
+            }
+            else if (key.upArrow || input === 'k') {
+                setSelectedIndex(prev => Math.max(prev - 1, 0));
+            }
+        }
+        // Refresh with 'r'
+        if (input === 'r') {
+            fetchBugs();
+        }
+    }, { isActive: isTTY });
+    // Reset selected index when filter changes
+    useEffect(() => {
+        setSelectedIndex(0);
+    }, [filter]);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { flexDirection: "column", borderStyle: activeSection === 'form' ? 'double' : 'single', borderColor: activeSection === 'form' ? 'cyan' : 'gray', padding: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Submit New Bug" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: formField === 'title' && activeSection === 'form' ? 'cyan' : 'white', children: "Title:" }), _jsxs(Text, { children: [title || (formField === 'title' && activeSection === 'form' ? '_' : ''), formField === 'title' && activeSection === 'form' && _jsx(Text, { color: "cyan", children: "|" })] })] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: formField === 'description' && activeSection === 'form' ? 'cyan' : 'white', children: "Description:" }), _jsxs(Text, { children: [description || (formField === 'description' && activeSection === 'form' ? '_' : ''), formField === 'description' && activeSection === 'form' && _jsx(Text, { color: "cyan", children: "|" })] })] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: formField === 'severity' && activeSection === 'form' ? 'cyan' : 'white', children: "Severity:" }), ['low', 'medium', 'high', 'critical'].map((s) => (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { backgroundColor: s === severity ? severityColors[s] : undefined, color: s === severity ? 'white' : severityColors[s], bold: s === severity, children: s === severity ? `[${s.toUpperCase()}]` : s }) }, s)))] }), _jsx(Box, { marginTop: 1, children: isSubmitting ? (_jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " Submitting..."] })) : submitMessage ? (_jsx(Text, { color: submitMessage.type === 'success' ? 'green' : 'red', children: submitMessage.text })) : (_jsx(Text, { dimColor: true, children: formField === 'severity' ? 'Press Enter to submit' : 'Navigate with arrows, Tab to filters' })) })] }), _jsxs(Box, { borderStyle: activeSection === 'filters' ? 'double' : 'single', borderColor: activeSection === 'filters' ? 'cyan' : 'gray', paddingX: 1, marginBottom: 1, children: [_jsx(Text, { children: "Filters: " }), ['all', 'open', 'closed'].map((f, i) => (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { dimColor: true, children: ["[", i + 1, "] "] }), _jsx(Text, { color: f === filter ? 'cyan' : 'white', bold: f === filter, underline: f === filter, children: f.charAt(0).toUpperCase() + f.slice(1) })] }, f))), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["(", filteredBugs.length, " bugs)"] }) })] }), _jsxs(Box, { flexDirection: "column", borderStyle: activeSection === 'list' ? 'double' : 'single', borderColor: activeSection === 'list' ? 'cyan' : 'gray', padding: 1, flexGrow: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Bug List" }), isLoading ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " Loading bugs..."] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "--- Loading... ---" }), _jsx(Text, { dimColor: true, children: "--- Loading... ---" }), _jsx(Text, { dimColor: true, children: "--- Loading... ---" })] })] })) : loadError ? (_jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: "red", children: ["Error: ", loadError] }), _jsx(Text, { dimColor: true, children: " (press r to retry)" })] })) : filteredBugs.length === 0 ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "No bugs found" }), _jsx(Text, { dimColor: true, children: filter === 'all'
+                                    ? 'Submit a bug above or wait for issues to appear'
+                                    : `No ${filter} bugs - try changing the filter` })] })) : (_jsx(Box, { flexDirection: "column", marginTop: 1, children: filteredBugs.map((bug, index) => (_jsxs(Box, { flexDirection: "row", paddingX: 1, marginBottom: 1, borderStyle: selectedIndex === index && activeSection === 'list' ? 'single' : undefined, borderColor: selectedIndex === index && activeSection === 'list' ? 'cyan' : undefined, children: [_jsx(Box, { width: 10, children: _jsx(Text, { color: "gray", children: bug.id }) }), _jsx(Box, { width: 10, children: _jsx(Text, { backgroundColor: severityColors[bug.priority] || 'gray', color: "white", children: ` ${(bug.priority || 'medium').toUpperCase()} ` }) }), _jsx(Box, { width: 12, children: _jsxs(Text, { color: statusColors[bug.status] || 'gray', children: ["[", bug.status, "]"] }) }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { children: bug.title || bug.description?.split('\n')[0] || 'Untitled' }) }), bug.createdAt && (_jsx(Box, { width: 12, children: _jsx(Text, { dimColor: true, children: bug.createdAt }) }))] }, bug.id))) }))] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Tab: section | Arrows: navigate | r: refresh | Enter: submit" }) })] }));
+}

package/dashboard/dist/components/BugsPane.test.d.ts

@@ -0,0 +1 @@
+export {};