app.js

function cveTracker() {
    return {
        query: '',
        loading: false,
        error: null,
        result: null,
        meta: {},
        yearCache: {},

        distros: [
            { name: 'debian', label: 'Debian', data: null, urlTemplate: 'https://security-tracker.debian.org/tracker/{cve}' },
            { name: 'ubuntu', label: 'Ubuntu', data: null, urlTemplate: 'https://ubuntu.com/security/{cve}' },
            { name: 'rhel', label: 'RHEL/CentOS', data: null, urlTemplate: 'https://access.redhat.com/security/cve/{cve}' },
            { name: 'alpine', label: 'Alpine', data: null, urlTemplate: 'https://security.alpinelinux.org/vuln/{cve}' },
        ],

        async init() {
            try {
                const response = await fetch('data/index.json');
                if (response.ok) {
                    const data = await response.json();
                    this.meta = data.meta || {};
                }
            } catch (e) {
                console.log('Index not loaded:', e);
            }

            // Check for ?cve= query parameter
            const params = new URLSearchParams(window.location.search);
            const cveParam = params.get('cve');
            if (cveParam) {
                this.query = cveParam.toUpperCase();
                this.search();
            }
        },

        async search() {
            const cveId = this.query.trim().toUpperCase();

            if (!cveId) {
                this.error = 'Please enter a CVE ID';
                return;
            }

            const cvePattern = /^CVE-\d{4}-\d{4,}$/;
            if (!cvePattern.test(cveId)) {
                this.error = 'Invalid CVE format. Use CVE-YYYY-NNNNN (e.g., CVE-2024-1234)';
                return;
            }

            this.loading = true;
            this.error = null;
            this.result = null;

            for (const distro of this.distros) {
                distro.data = null;
            }

            try {
                const year = cveId.split('-')[1];
                const yearFile = `data/cve-${year}.json`;

                let yearData = this.yearCache[year];
                if (!yearData) {
                    const response = await fetch(yearFile);
                    if (!response.ok) {
                        this.error = `No data available for year ${year}`;
                        this.loading = false;
                        return;
                    }
                    yearData = await response.json();
                    this.yearCache[year] = yearData;
                }

                const cveData = yearData?.cves?.[cveId];

                this.result = {
                    cve_id: cveId,
                    notInCache: !cveData,
                    ...(cveData || {})
                };

                for (const distro of this.distros) {
                    distro.data = cveData?.distros?.[distro.name] || null;
                }

            } catch (e) {
                // Even on error, show distro cards for manual lookup
                this.result = {
                    cve_id: cveId,
                    notInCache: true
                };
                for (const distro of this.distros) {
                    distro.data = null;
                }
            }

            // Update URL for sharing
            const url = new URL(window.location);
            url.searchParams.set('cve', cveId);
            window.history.replaceState({}, '', url);

            this.loading = false;
        },

        getStatusClass(distro) {
            if (!distro.data) return 'status-unknown';
            return 'status-' + (distro.data.status || 'unknown');
        },

        formatStatus(status) {
            if (!status) return 'Unknown';
            const labels = {
                'fixed': 'Fixed',
                'affected': 'Affected',
                'not-affected': 'Not Affected',
                'unknown': 'Unknown',
                'wontfix': "Won't Fix",
                'deferred': 'Deferred'
            };
            return labels[status] || status;
        },

        formatFixed(fixed) {
            if (!fixed) return '';
            if (Array.isArray(fixed)) {
                return fixed.join(', ');
            }
            return fixed;
        },

        formatDate(isoDate) {
            if (!isoDate) return '';
            try {
                return new Date(isoDate).toLocaleDateString('en-US', {
                    month: 'short',
                    day: 'numeric',
                    hour: '2-digit',
                    minute: '2-digit'
                });
            } catch {
                return isoDate;
            }
        },

        sortedReleases(releases) {
            if (!releases) return [];
            return Object.keys(releases).sort((a, b) => {
                // Natural sort: handle numbers properly (RHEL 8 before RHEL 10)
                return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
            });
        },

        getDistroUrl(distro) {
            const cveId = this.result?.cve_id || this.query.trim().toUpperCase();
            if (!cveId) return '#';
            if (distro.data?.advisory_url) return distro.data.advisory_url;
            return distro.urlTemplate.replace('{cve}', cveId);
        }
    };
}