ghcrawl 0.0.1 → 0.1.1

package/dist/tui/app.js

@@ -0,0 +1,1055 @@
+import { spawn } from 'node:child_process';
+import blessed from 'neo-blessed';
+import { getTuiRepositoryPreference, writeTuiRepositoryPreference } from '@ghcrawl/api-core';
+import { buildMemberRows, cycleFocusPane, cycleMinSizeFilter, cycleSortMode, findSelectableIndex, moveSelectableIndex, preserveSelectedId, selectedThreadIdFromRow, } from './state.js';
+import { computeTuiLayout } from './layout.js';
+export function resolveBlessedTerminal(env = process.env) {
+    const term = env.TERM;
+    if (!term) {
+        return undefined;
+    }
+    if (term === 'xterm-ghostty') {
+        return 'xterm-256color';
+    }
+    return term;
+}
+function createScreen(options) {
+    return blessed.screen({
+        ...options,
+        terminal: resolveBlessedTerminal(),
+    });
+}
+const ACTIVITY_LOG_LIMIT = 200;
+const FOOTER_LOG_LINES = 4;
+const UPDATE_TASK_ORDER = ['sync', 'embed', 'cluster'];
+export async function startTui(params) {
+    const selectedRepository = params.owner && params.repo ? { owner: params.owner, repo: params.repo } : null;
+    let currentRepository = selectedRepository ?? { owner: '', repo: '' };
+    const widgets = createWidgets(currentRepository.owner, currentRepository.repo);
+    let focusPane = 'clusters';
+    const initialPreference = selectedRepository
+        ? getTuiRepositoryPreference(params.service.config, currentRepository.owner, currentRepository.repo)
+        : { sortMode: 'recent', minClusterSize: 10 };
+    let sortMode = initialPreference.sortMode;
+    let minSize = initialPreference.minClusterSize;
+    let search = '';
+    let snapshot = null;
+    let clusterDetail = null;
+    let threadDetail = null;
+    let selectedClusterId = null;
+    let selectedMemberThreadId = null;
+    let memberRows = [];
+    let memberIndex = -1;
+    let status = 'Ready';
+    const activityLines = [];
+    const clusterDetailCache = new Map();
+    const threadDetailCache = new Map();
+    let syncJobRunning = false;
+    let embedJobRunning = false;
+    let clusterJobRunning = false;
+    let modalOpen = false;
+    const clearCaches = () => {
+        clusterDetailCache.clear();
+        threadDetailCache.clear();
+    };
+    const pushActivity = (message) => {
+        activityLines.push(`${formatActivityTimestamp()} ${message}`);
+        if (activityLines.length > ACTIVITY_LOG_LIMIT) {
+            activityLines.splice(0, activityLines.length - ACTIVITY_LOG_LIMIT);
+        }
+        render();
+    };
+    const loadClusterDetail = (clusterId) => {
+        const cached = clusterDetailCache.get(clusterId);
+        if (cached)
+            return cached;
+        const detail = params.service.getTuiClusterDetail({
+            owner: currentRepository.owner,
+            repo: currentRepository.repo,
+            clusterId,
+        });
+        clusterDetailCache.set(clusterId, detail);
+        return detail;
+    };
+    const loadThreadDetail = (threadId, includeNeighbors) => {
+        const cached = threadDetailCache.get(threadId);
+        if (cached && (cached.hasNeighbors || !includeNeighbors)) {
+            return cached.detail;
+        }
+        const detail = params.service.getTuiThreadDetail({
+            owner: currentRepository.owner,
+            repo: currentRepository.repo,
+            threadId,
+            includeNeighbors,
+        });
+        threadDetailCache.set(threadId, { detail, hasNeighbors: includeNeighbors });
+        return detail;
+    };
+    const loadSelectedThreadDetail = (includeNeighbors) => {
+        threadDetail = selectedMemberThreadId !== null ? loadThreadDetail(selectedMemberThreadId, includeNeighbors) : null;
+    };
+    const refreshAll = (preserveSelection) => {
+        const previousClusterId = preserveSelection ? selectedClusterId : null;
+        const previousMemberId = preserveSelection ? selectedMemberThreadId : null;
+        clearCaches();
+        snapshot = params.service.getTuiSnapshot({
+            owner: currentRepository.owner,
+            repo: currentRepository.repo,
+            minSize,
+            sort: sortMode,
+            search,
+        });
+        selectedClusterId = preserveSelectedId(snapshot.clusters.map((cluster) => cluster.clusterId), previousClusterId);
+        if (selectedClusterId !== null) {
+            clusterDetail = loadClusterDetail(selectedClusterId);
+            memberRows = buildMemberRows(clusterDetail);
+            selectedMemberThreadId = preserveSelectedId(memberRows.filter((row) => row.selectable).map((row) => row.threadId), previousMemberId);
+            memberIndex = findSelectableIndex(memberRows, selectedMemberThreadId);
+            loadSelectedThreadDetail(false);
+        }
+        else {
+            clusterDetail = null;
+            memberRows = [];
+            selectedMemberThreadId = null;
+            memberIndex = -1;
+            threadDetail = null;
+        }
+        status = `Loaded ${snapshot.clusters.length} cluster(s)`;
+        render();
+    };
+    const updateFocus = (nextFocus) => {
+        focusPane = nextFocus;
+        if (focusPane === 'detail' && selectedMemberThreadId !== null) {
+            loadSelectedThreadDetail(true);
+        }
+        if (focusPane === 'clusters')
+            widgets.clusters.focus();
+        if (focusPane === 'members')
+            widgets.members.focus();
+        if (focusPane === 'detail')
+            widgets.detail.focus();
+        render();
+    };
+    const render = () => {
+        const width = widgets.screen.width;
+        const height = widgets.screen.height;
+        const layout = computeTuiLayout(width, height);
+        applyRect(widgets.header, layout.header);
+        applyRect(widgets.clusters, layout.clusters);
+        applyRect(widgets.members, layout.members);
+        applyRect(widgets.detail, layout.detail);
+        applyRect(widgets.footer, layout.footer);
+        widgets.screen.title = currentRepository.owner && currentRepository.repo ? `ghcrawl ${currentRepository.owner}/${currentRepository.repo}` : 'ghcrawl';
+        const repoLabel = snapshot?.repository.fullName ?? (currentRepository.owner && currentRepository.repo ? `${currentRepository.owner}/${currentRepository.repo}` : 'ghcrawl');
+        const ghStatus = formatRelativeTime(snapshot?.stats.lastGithubReconciliationAt ?? null);
+        const embedAge = formatRelativeTime(snapshot?.stats.lastEmbedRefreshAt ?? null);
+        const embedStatus = snapshot && snapshot.stats.staleEmbedThreadCount > 0
+            ? `${snapshot.stats.staleEmbedThreadCount} stale / ${embedAge}`
+            : embedAge;
+        const clusterStatus = snapshot?.stats.latestClusterRunId != null
+            ? `#${snapshot.stats.latestClusterRunId} ${formatRelativeTime(snapshot.stats.latestClusterRunFinishedAt ?? null)}`
+            : 'never';
+        widgets.header.setContent(`{bold}${repoLabel}{/bold}  {cyan-fg}${snapshot?.stats.openPullRequestCount ?? 0} PR{/cyan-fg}  {green-fg}${snapshot?.stats.openIssueCount ?? 0} issues{/green-fg}  GH:${ghStatus}  Emb:${embedStatus}  Cl:${clusterStatus}  sort:${sortMode}  min:${minSize === 0 ? 'all' : `${minSize}+`}  filter:${search || 'none'}`);
+        const clusterItems = snapshot
+            ? snapshot.clusters.map((cluster) => {
+                const updated = cluster.latestUpdatedAt ? cluster.latestUpdatedAt.slice(5, 16).replace('T', ' ') : 'unknown';
+                return `${String(cluster.totalCount).padStart(3, ' ')}  ${String(cluster.pullRequestCount).padStart(2, ' ')}P/${String(cluster.issueCount).padStart(2, ' ')}I  ${updated}  ${cluster.displayTitle}`;
+            })
+            : ['Pick a repository with p'];
+        widgets.clusters.setItems(clusterItems);
+        const clusterIndex = snapshot && selectedClusterId !== null ? Math.max(0, snapshot.clusters.findIndex((cluster) => cluster.clusterId === selectedClusterId)) : 0;
+        widgets.clusters.select(clusterIndex);
+        widgets.members.setItems(memberRows.length > 0 ? memberRows.map((row) => row.label) : ['No members']);
+        if (memberIndex >= 0) {
+            widgets.members.select(memberIndex);
+        }
+        widgets.detail.setContent(renderDetailPane(threadDetail, clusterDetail, focusPane));
+        updatePaneStyles(widgets, focusPane);
+        const activeJobs = [syncJobRunning ? 'sync' : null, embedJobRunning ? 'embed' : null, clusterJobRunning ? 'cluster' : null]
+            .filter(Boolean)
+            .join(', ') || 'idle';
+        const logLines = activityLines.slice(-FOOTER_LOG_LINES);
+        const footerLines = [...logLines];
+        while (footerLines.length < FOOTER_LOG_LINES) {
+            footerLines.unshift('');
+        }
+        footerLines.push(`${status}  |  jobs:${activeJobs}  |  Tab focus  j/k move-or-scroll  PgUp/PgDn scroll  p repos  g update  s sort  f min  / filter  r refresh  o open  q quit`);
+        widgets.footer.setContent(footerLines.join('\n'));
+        widgets.screen.render();
+    };
+    const resetDetailScroll = () => {
+        widgets.detail.setScroll(0);
+    };
+    const scrollDetail = (offset) => {
+        if (focusPane !== 'detail')
+            return;
+        widgets.detail.scroll(offset);
+        widgets.screen.render();
+    };
+    const runSyncStep = async () => {
+        if (syncJobRunning) {
+            throw new Error('GitHub reconciliation already running');
+        }
+        syncJobRunning = true;
+        status = 'Running GitHub reconciliation';
+        pushActivity('[jobs] starting GitHub reconciliation');
+        render();
+        try {
+            const result = await params.service.syncRepository({
+                owner: currentRepository.owner,
+                repo: currentRepository.repo,
+                onProgress: pushActivity,
+            });
+            pushActivity(`[jobs] GitHub reconciliation complete threads=${result.threadsSynced} comments=${result.commentsSynced} closed=${result.threadsClosed}`);
+            refreshAll(true);
+        }
+        finally {
+            syncJobRunning = false;
+            status = 'Ready';
+            render();
+        }
+    };
+    const runEmbedStep = async () => {
+        if (embedJobRunning) {
+            throw new Error('embed refresh already running');
+        }
+        embedJobRunning = true;
+        status = 'Running embed refresh';
+        pushActivity('[jobs] starting embed refresh');
+        render();
+        try {
+            const result = await params.service.embedRepository({
+                owner: currentRepository.owner,
+                repo: currentRepository.repo,
+                onProgress: pushActivity,
+            });
+            pushActivity(`[jobs] embed refresh complete embeddings=${result.embedded}`);
+            refreshAll(true);
+        }
+        finally {
+            embedJobRunning = false;
+            status = 'Ready';
+            render();
+        }
+    };
+    const runClusterStep = async () => {
+        if (clusterJobRunning) {
+            throw new Error('cluster refresh already running');
+        }
+        clusterJobRunning = true;
+        status = 'Running cluster refresh';
+        pushActivity('[jobs] starting cluster refresh');
+        render();
+        try {
+            const result = params.service.clusterRepository({
+                owner: currentRepository.owner,
+                repo: currentRepository.repo,
+                onProgress: pushActivity,
+            });
+            pushActivity(`[jobs] cluster refresh complete clusters=${result.clusters} edges=${result.edges}`);
+            refreshAll(true);
+        }
+        finally {
+            clusterJobRunning = false;
+            status = 'Ready';
+            render();
+        }
+    };
+    const moveSelection = (delta) => {
+        if (!snapshot)
+            return;
+        if (focusPane === 'clusters') {
+            if (snapshot.clusters.length === 0)
+                return;
+            const currentIndex = Math.max(0, snapshot.clusters.findIndex((cluster) => cluster.clusterId === selectedClusterId));
+            const nextIndex = (currentIndex + delta + snapshot.clusters.length) % snapshot.clusters.length;
+            selectedClusterId = snapshot.clusters[nextIndex]?.clusterId ?? null;
+            if (selectedClusterId !== null) {
+                clusterDetail = loadClusterDetail(selectedClusterId);
+                memberRows = buildMemberRows(clusterDetail);
+                selectedMemberThreadId = preserveSelectedId(memberRows.filter((row) => row.selectable).map((row) => row.threadId), null);
+                memberIndex = findSelectableIndex(memberRows, selectedMemberThreadId);
+                loadSelectedThreadDetail(false);
+                resetDetailScroll();
+            }
+            status = `Cluster ${nextIndex + 1}/${snapshot.clusters.length}`;
+            render();
+            return;
+        }
+        if (focusPane === 'members') {
+            if (memberRows.length === 0)
+                return;
+            memberIndex = moveSelectableIndex(memberRows, memberIndex < 0 ? 0 : memberIndex, delta);
+            selectedMemberThreadId = selectedThreadIdFromRow(memberRows, memberIndex);
+            loadSelectedThreadDetail(false);
+            resetDetailScroll();
+            status = selectedMemberThreadId !== null ? `Selected #${threadDetail?.thread.number ?? '?'}` : 'No selectable member';
+            render();
+        }
+    };
+    const promptFilter = () => {
+        modalOpen = true;
+        const prompt = blessed.prompt({
+            parent: widgets.screen,
+            border: 'line',
+            height: 7,
+            width: '60%',
+            top: 'center',
+            left: 'center',
+            label: ' Cluster Filter ',
+            tags: true,
+            keys: true,
+            vi: true,
+            style: {
+                border: { fg: 'cyan' },
+                bg: '#101522',
+            },
+        });
+        prompt.input('Filter clusters', search, (_error, value) => {
+            search = (value ?? '').trim();
+            status = search ? `Filter: ${search}` : 'Filter cleared';
+            refreshAll(false);
+            prompt.destroy();
+            modalOpen = false;
+            updateFocus('clusters');
+        });
+    };
+    const openSelectedThread = () => {
+        const url = threadDetail?.thread.htmlUrl;
+        if (!url) {
+            status = 'No thread selected to open';
+            render();
+            return;
+        }
+        openUrl(url);
+        status = `Opened ${url}`;
+        render();
+    };
+    const promptUpdatePipeline = () => {
+        if (modalOpen || hasActiveJobs()) {
+            if (hasActiveJobs()) {
+                pushActivity('[jobs] update pipeline is unavailable while another job is running');
+            }
+            return;
+        }
+        void (async () => {
+            modalOpen = true;
+            try {
+                const selection = await promptUpdatePipelineSelection(widgets.screen, snapshot?.stats ?? null);
+                if (!selection) {
+                    render();
+                    return;
+                }
+                const selectedTasks = UPDATE_TASK_ORDER.filter((task) => selection[task]).join(' -> ');
+                pushActivity(`[jobs] queued update pipeline: ${selectedTasks}`);
+                await runUpdatePipeline(selection);
+                updateFocus('clusters');
+            }
+            finally {
+                modalOpen = false;
+            }
+        })();
+    };
+    const hasActiveJobs = () => syncJobRunning || embedJobRunning || clusterJobRunning;
+    const runUpdatePipeline = async (selection) => {
+        if (hasActiveJobs()) {
+            pushActivity('[jobs] another update pipeline is already running');
+            return false;
+        }
+        try {
+            if (selection.sync) {
+                await runSyncStep();
+            }
+            if (selection.embed) {
+                await runEmbedStep();
+            }
+            if (selection.cluster) {
+                await runClusterStep();
+            }
+            return true;
+        }
+        catch (error) {
+            pushActivity(`[jobs] update pipeline failed: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    };
+    const persistRepositoryPreference = () => {
+        writeTuiRepositoryPreference(params.service.config, {
+            owner: currentRepository.owner,
+            repo: currentRepository.repo,
+            minClusterSize: minSize,
+            sortMode,
+        });
+    };
+    const switchRepository = (target, overrides) => {
+        currentRepository = target;
+        const preference = getTuiRepositoryPreference(params.service.config, target.owner, target.repo);
+        minSize = overrides?.minClusterSize ?? preference.minClusterSize;
+        sortMode = overrides?.sortMode ?? preference.sortMode;
+        persistRepositoryPreference();
+        clearCaches();
+        search = '';
+        snapshot = null;
+        clusterDetail = null;
+        threadDetail = null;
+        selectedClusterId = null;
+        selectedMemberThreadId = null;
+        memberRows = [];
+        memberIndex = -1;
+        status = `Switched to ${target.owner}/${target.repo}`;
+        refreshAll(false);
+    };
+    const runRepositoryBootstrap = async (target) => {
+        if (hasActiveJobs()) {
+            pushActivity('[repo] repository setup is blocked while jobs are already running');
+            return false;
+        }
+        status = `Bootstrapping ${target.owner}/${target.repo}`;
+        render();
+        try {
+            pushActivity(`[repo] starting initial update pipeline for ${target.owner}/${target.repo}`);
+            const previousRepository = currentRepository;
+            let ok = false;
+            try {
+                currentRepository = target;
+                ok = await runUpdatePipeline({ sync: true, embed: true, cluster: true });
+            }
+            finally {
+                currentRepository = previousRepository;
+            }
+            if (!ok) {
+                return false;
+            }
+            pushActivity(`[repo] initial setup complete for ${target.owner}/${target.repo}`);
+            switchRepository(target, { minClusterSize: 1 });
+            return true;
+        }
+        catch (error) {
+            pushActivity(`[repo] initial setup failed for ${target.owner}/${target.repo}: ${error instanceof Error ? error.message : String(error)}`);
+            status = 'Ready';
+            render();
+            return false;
+        }
+    };
+    const browseRepositories = () => {
+        if (modalOpen)
+            return;
+        if (hasActiveJobs()) {
+            pushActivity('[repo] repository switching is disabled while jobs are running');
+            return;
+        }
+        void (async () => {
+            modalOpen = true;
+            try {
+                const choice = await promptRepositoryChoice(widgets.screen, params.service);
+                if (!choice) {
+                    render();
+                    return;
+                }
+                if (choice.kind === 'existing') {
+                    switchRepository(choice.target);
+                    pushActivity(`[repo] switched to ${choice.target.owner}/${choice.target.repo}`);
+                    updateFocus('clusters');
+                    return;
+                }
+                const target = await promptRepositoryInput(widgets.screen);
+                if (!target) {
+                    render();
+                    return;
+                }
+                await runRepositoryBootstrap(target);
+                updateFocus('clusters');
+            }
+            finally {
+                modalOpen = false;
+            }
+        })();
+    };
+    const initializeRepositorySelection = async () => {
+        if (selectedRepository) {
+            return true;
+        }
+        modalOpen = true;
+        try {
+            const choice = await promptRepositoryChoice(widgets.screen, params.service);
+            if (!choice) {
+                return false;
+            }
+            if (choice.kind === 'existing') {
+                switchRepository(choice.target);
+                pushActivity(`[repo] opened ${choice.target.owner}/${choice.target.repo}`);
+                updateFocus('clusters');
+                return true;
+            }
+            const target = await promptRepositoryInput(widgets.screen);
+            if (!target) {
+                return false;
+            }
+            const ready = await runRepositoryBootstrap(target);
+            if (!ready) {
+                return false;
+            }
+            updateFocus('clusters');
+            return true;
+        }
+        finally {
+            modalOpen = false;
+        }
+    };
+    widgets.screen.key(['q', 'C-c'], () => {
+        widgets.screen.destroy();
+    });
+    widgets.screen.key(['tab'], () => {
+        if (modalOpen)
+            return;
+        updateFocus(cycleFocusPane(focusPane, 1));
+    });
+    widgets.screen.key(['S-tab'], () => {
+        if (modalOpen)
+            return;
+        updateFocus(cycleFocusPane(focusPane, -1));
+    });
+    widgets.screen.key(['j', 'down'], () => {
+        if (modalOpen)
+            return;
+        if (focusPane === 'detail') {
+            scrollDetail(3);
+            return;
+        }
+        moveSelection(1);
+    });
+    widgets.screen.key(['k', 'up'], () => {
+        if (modalOpen)
+            return;
+        if (focusPane === 'detail') {
+            scrollDetail(-3);
+            return;
+        }
+        moveSelection(-1);
+    });
+    widgets.screen.key(['pageup'], () => {
+        if (modalOpen)
+            return;
+        scrollDetail(-12);
+    });
+    widgets.screen.key(['pagedown'], () => {
+        if (modalOpen)
+            return;
+        scrollDetail(12);
+    });
+    widgets.screen.key(['home'], () => {
+        if (modalOpen)
+            return;
+        if (focusPane !== 'detail')
+            return;
+        widgets.detail.setScroll(0);
+        widgets.screen.render();
+    });
+    widgets.screen.key(['end'], () => {
+        if (modalOpen)
+            return;
+        if (focusPane !== 'detail')
+            return;
+        widgets.detail.setScrollPerc(100);
+        widgets.screen.render();
+    });
+    widgets.screen.key(['enter'], () => {
+        if (modalOpen)
+            return;
+        if (focusPane === 'clusters') {
+            updateFocus('members');
+            return;
+        }
+        if (focusPane === 'members') {
+            loadSelectedThreadDetail(true);
+            status = selectedMemberThreadId !== null ? `Loaded neighbors for #${threadDetail?.thread.number ?? '?'}` : status;
+            updateFocus('detail');
+        }
+    });
+    widgets.screen.key(['s'], () => {
+        if (modalOpen)
+            return;
+        sortMode = cycleSortMode(sortMode);
+        persistRepositoryPreference();
+        status = `Sort: ${sortMode}`;
+        refreshAll(false);
+    });
+    widgets.screen.key(['f'], () => {
+        if (modalOpen)
+            return;
+        minSize = cycleMinSizeFilter(minSize);
+        persistRepositoryPreference();
+        status = `Min size: ${minSize === 0 ? 'all' : `${minSize}+`}`;
+        refreshAll(false);
+    });
+    widgets.screen.key(['/'], () => {
+        if (modalOpen)
+            return;
+        promptFilter();
+    });
+    widgets.screen.key(['p'], () => browseRepositories());
+    widgets.screen.key(['g'], () => {
+        if (modalOpen)
+            return;
+        promptUpdatePipeline();
+    });
+    widgets.screen.key(['r'], () => {
+        if (modalOpen)
+            return;
+        status = 'Refreshing';
+        refreshAll(true);
+    });
+    widgets.screen.key(['o'], () => {
+        if (modalOpen)
+            return;
+        openSelectedThread();
+    });
+    widgets.screen.on('resize', () => render());
+    widgets.screen.on('destroy', () => {
+        widgets.screen.program.showCursor();
+    });
+    widgets.screen.program.hideCursor();
+    if (selectedRepository) {
+        refreshAll(false);
+    }
+    else {
+        status = 'Pick a repository';
+        render();
+        const ready = await initializeRepositorySelection();
+        if (!ready) {
+            widgets.screen.destroy();
+            return;
+        }
+    }
+    pushActivity('[jobs] press g to run the staged update pipeline: GitHub sync, embeddings, then clusters');
+    updateFocus('clusters');
+    await new Promise((resolve) => widgets.screen.once('destroy', () => resolve()));
+}
+function createWidgets(owner, repo) {
+    const screen = createScreen({
+        smartCSR: true,
+        fullUnicode: true,
+        dockBorders: true,
+        autoPadding: false,
+        title: owner && repo ? `ghcrawl ${owner}/${repo}` : 'ghcrawl',
+    });
+    const header = blessed.box({
+        parent: screen,
+        tags: true,
+        style: { fg: 'white', bg: '#0d1321' },
+    });
+    const clusters = blessed.list({
+        parent: screen,
+        border: 'line',
+        label: ' Clusters ',
+        tags: false,
+        keys: false,
+        style: {
+            border: { fg: '#5bc0eb' },
+            item: { fg: 'white' },
+            selected: { bg: '#5bc0eb', fg: 'black', bold: true },
+        },
+        scrollbar: { ch: ' ' },
+    });
+    const members = blessed.list({
+        parent: screen,
+        border: 'line',
+        label: ' Members ',
+        tags: false,
+        keys: false,
+        style: {
+            border: { fg: '#9bc53d' },
+            item: { fg: 'white' },
+            selected: { bg: '#9bc53d', fg: 'black', bold: true },
+        },
+        scrollbar: { ch: ' ' },
+    });
+    const detail = blessed.box({
+        parent: screen,
+        border: 'line',
+        label: ' Detail ',
+        tags: true,
+        scrollable: true,
+        alwaysScroll: true,
+        keys: false,
+        scrollbar: { ch: ' ' },
+        style: {
+            border: { fg: '#fde74c' },
+            fg: 'white',
+        },
+    });
+    const footer = blessed.box({
+        parent: screen,
+        tags: false,
+        style: { fg: 'black', bg: '#5bc0eb' },
+    });
+    return { screen, header, clusters, members, detail, footer };
+}
+function updatePaneStyles(widgets, focus) {
+    widgets.clusters.style.border = { fg: focus === 'clusters' ? 'white' : '#5bc0eb' };
+    widgets.members.style.border = { fg: focus === 'members' ? 'white' : '#9bc53d' };
+    widgets.detail.style.border = { fg: focus === 'detail' ? 'white' : '#fde74c' };
+}
+export function renderDetailPane(threadDetail, clusterDetail, focusPane) {
+    if (!clusterDetail) {
+        return 'No cluster selected.\n\nRun `ghcrawl cluster owner/repo` if you have not clustered this repository yet.';
+    }
+    if (!threadDetail) {
+        return `{bold}${escapeBlessedText(clusterDetail.displayTitle)}{/bold}\n\nSelect a member to inspect thread details.`;
+    }
+    const thread = threadDetail.thread;
+    const labels = thread.labels.length > 0 ? escapeBlessedText(thread.labels.join(', ')) : 'none';
+    const summaries = Object.entries(threadDetail.summaries)
+        .map(([key, value]) => `{bold}${key}:{/bold}\n${escapeBlessedText(value)}`)
+        .join('\n\n');
+    const neighbors = threadDetail.neighbors.length > 0
+        ? threadDetail.neighbors
+            .map((neighbor) => `#${neighbor.number} ${neighbor.kind} ${(neighbor.score * 100).toFixed(1)}%  ${escapeBlessedText(neighbor.title)}`)
+            .join('\n')
+        : focusPane === 'detail'
+            ? 'No neighbors available.'
+            : 'Neighbors load when the detail pane is focused.';
+    return [
+        `{bold}${thread.kind} #${thread.number}{/bold}  ${escapeBlessedText(thread.title)}`,
+        '',
+        `{bold}Author:{/bold} ${escapeBlessedText(thread.authorLogin ?? 'unknown')}`,
+        `{bold}Updated:{/bold} ${thread.updatedAtGh ?? 'unknown'}`,
+        `{bold}Labels:{/bold} ${labels}`,
+        `{bold}URL:{/bold} ${escapeBlessedText(thread.htmlUrl)}`,
+        '',
+        `{bold}Body{/bold}`,
+        escapeBlessedText(thread.body ?? '(no body)'),
+        summaries ? `\n\n${summaries}` : '',
+        `\n\n{bold}Neighbors{/bold}\n${neighbors}`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+export function escapeBlessedText(value) {
+    return value.replace(/\\/g, '\\\\').replace(/\{/g, '\\{').replace(/\}/g, '\\}');
+}
+function applyRect(element, rect) {
+    element.top = rect.top;
+    element.left = rect.left;
+    element.width = rect.width;
+    element.height = rect.height;
+}
+function openUrl(url) {
+    const launch = process.platform === 'darwin'
+        ? { command: 'open', args: [url] }
+        : process.platform === 'win32'
+            ? { command: 'cmd', args: ['/c', 'start', '', url] }
+            : { command: 'xdg-open', args: [url] };
+    const child = spawn(launch.command, launch.args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsVerbatimArguments: process.platform === 'win32',
+    });
+    child.unref();
+}
+export function describeUpdateTask(task, stats, now = new Date()) {
+    if (!stats) {
+        if (task === 'sync')
+            return 'recommended';
+        if (task === 'embed')
+            return 'recommended after sync';
+        return 'recommended after embeddings';
+    }
+    if (task === 'sync') {
+        return stats.lastGithubReconciliationAt
+            ? `up to date, last ${formatRelativeTime(stats.lastGithubReconciliationAt, now)}`
+            : 'never run';
+    }
+    if (task === 'embed') {
+        if (!stats.lastEmbedRefreshAt)
+            return 'never run';
+        if (stats.staleEmbedThreadCount > 0) {
+            return `outdated: ${stats.staleEmbedThreadCount} stale, last ${formatRelativeTime(stats.lastEmbedRefreshAt, now)}`;
+        }
+        const syncMs = parseDateOrNull(stats.lastGithubReconciliationAt);
+        const embedMs = parseDateOrNull(stats.lastEmbedRefreshAt);
+        if (syncMs !== null && embedMs !== null && embedMs < syncMs) {
+            return `outdated: GitHub is newer by ${formatAge(syncMs - embedMs)}`;
+        }
+        return `up to date, last ${formatRelativeTime(stats.lastEmbedRefreshAt, now)}`;
+    }
+    if (!stats.latestClusterRunFinishedAt)
+        return 'never run';
+    const embedMs = parseDateOrNull(stats.lastEmbedRefreshAt);
+    const clusterMs = parseDateOrNull(stats.latestClusterRunFinishedAt);
+    if (embedMs !== null && clusterMs !== null && clusterMs < embedMs) {
+        return `outdated: embeddings are newer by ${formatAge(embedMs - clusterMs)}`;
+    }
+    return `up to date, last ${formatRelativeTime(stats.latestClusterRunFinishedAt, now)}`;
+}
+export function buildUpdatePipelineLabels(stats, selection, now = new Date()) {
+    return UPDATE_TASK_ORDER.map((task) => {
+        const mark = selection[task] ? '[x]' : '[ ]';
+        const title = task === 'sync' ? 'GitHub sync/reconcile' : task === 'embed' ? 'Embed refresh' : 'Cluster rebuild';
+        return `${mark} ${title}  ${describeUpdateTask(task, stats, now)}`;
+    });
+}
+async function promptUpdatePipelineSelection(screen, stats) {
+    const selection = { sync: true, embed: true, cluster: true };
+    const modalWidth = '76%';
+    const box = blessed.list({
+        parent: screen,
+        border: 'line',
+        label: ' Update Pipeline ',
+        keys: true,
+        vi: true,
+        mouse: false,
+        top: 'center',
+        left: 'center',
+        width: modalWidth,
+        height: 11,
+        style: {
+            border: { fg: '#5bc0eb' },
+            item: { fg: 'white' },
+            selected: { bg: '#5bc0eb', fg: 'black', bold: true },
+        },
+        items: buildUpdatePipelineLabels(stats, selection),
+    });
+    const help = blessed.box({
+        parent: screen,
+        top: 'center-4',
+        left: 'center',
+        width: modalWidth,
+        height: 4,
+        style: { fg: 'white', bg: '#101522' },
+        content: 'Usually you want all three. Run order is fixed: GitHub sync/reconcile -> embeddings -> clusters.\n' +
+            'Toggle with space, move with j/k or arrows, Enter to start, Esc to cancel.',
+    });
+    box.focus();
+    box.select(0);
+    screen.render();
+    return await new Promise((resolve) => {
+        const getSelectedIndex = () => {
+            const selectedIndex = box.selected;
+            return typeof selectedIndex === 'number' && selectedIndex >= 0 ? selectedIndex : 0;
+        };
+        const refreshItems = () => {
+            const selectedIndex = getSelectedIndex();
+            box.setItems(buildUpdatePipelineLabels(stats, selection));
+            box.select(selectedIndex);
+            screen.render();
+        };
+        const finish = (value) => {
+            screen.off('keypress', handleKeypress);
+            box.destroy();
+            help.destroy();
+            screen.render();
+            resolve(value);
+        };
+        const handleKeypress = (_char, key) => {
+            if (key.name === 'escape') {
+                finish(null);
+                return;
+            }
+            if (key.name === 'space') {
+                const index = getSelectedIndex();
+                const task = UPDATE_TASK_ORDER[index];
+                if (!task)
+                    return;
+                selection[task] = !selection[task];
+                if (!selection.sync && !selection.embed && !selection.cluster) {
+                    selection[task] = true;
+                }
+                refreshItems();
+            }
+        };
+        screen.on('keypress', handleKeypress);
+        box.on('select', () => finish({ ...selection }));
+    });
+}
+export function getRepositoryChoices(service, now = new Date()) {
+    const repositories = service.listRepositories().repositories
+        .slice()
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || left.fullName.localeCompare(right.fullName));
+    return [
+        ...repositories.map((repository) => ({
+            kind: 'existing',
+            target: { owner: repository.owner, repo: repository.name },
+            label: `${repository.fullName}  ${formatRelativeTime(repository.updatedAt, now)}`,
+        })),
+        { kind: 'new', label: '+ Sync a new repository' },
+    ];
+}
+async function promptRepositoryChoice(screen, service) {
+    const choices = getRepositoryChoices(service);
+    const box = blessed.list({
+        parent: screen,
+        border: 'line',
+        label: ' Repositories ',
+        keys: true,
+        vi: true,
+        mouse: false,
+        top: 'center',
+        left: 'center',
+        width: '70%',
+        height: '70%',
+        style: {
+            border: { fg: '#5bc0eb' },
+            item: { fg: 'white' },
+            selected: { bg: '#5bc0eb', fg: 'black', bold: true },
+        },
+        items: choices.map((choice) => choice.label),
+    });
+    const help = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        width: '100%',
+        height: 1,
+        content: 'Select a repository with Enter. Press n for a new repo. Esc cancels.',
+        style: { fg: 'black', bg: '#5bc0eb' },
+    });
+    box.focus();
+    box.select(0);
+    screen.render();
+    return await new Promise((resolve) => {
+        const teardown = () => {
+            screen.off('keypress', handleKeypress);
+            box.destroy();
+            help.destroy();
+            screen.render();
+        };
+        const finish = (value) => {
+            teardown();
+            resolve(value);
+        };
+        const handleKeypress = (_char, key) => {
+            if (key.name === 'escape') {
+                finish(null);
+                return;
+            }
+            if (key.name === 'n') {
+                const newIndex = choices.findIndex((choice) => choice.kind === 'new');
+                if (newIndex >= 0) {
+                    box.select(newIndex);
+                    screen.render();
+                }
+            }
+        };
+        screen.on('keypress', handleKeypress);
+        box.on('select', (_item, index) => finish(choices[index] ?? null));
+    });
+}
+async function promptRepositoryInput(screen) {
+    const prompt = blessed.prompt({
+        parent: screen,
+        border: 'line',
+        height: 7,
+        width: '60%',
+        top: 'center',
+        left: 'center',
+        label: ' Repository ',
+        tags: true,
+        keys: true,
+        vi: true,
+        style: {
+            border: { fg: 'cyan' },
+            bg: '#101522',
+        },
+    });
+    return await new Promise((resolve) => {
+        prompt.input('Repository to sync (owner/repo)', '', (_error, value) => {
+            prompt.destroy();
+            const parsed = parseOwnerRepoValue((value ?? '').trim());
+            resolve(parsed);
+        });
+    });
+}
+async function runColdStartSetup(service, screen, target, log, footer) {
+    log?.log(`[setup] starting initial setup for ${target.owner}/${target.repo}`);
+    footer?.setContent('Running initial sync, embed, and cluster. This can take a while.');
+    screen.render();
+    try {
+        const reporter = (message) => {
+            log?.log(message);
+            screen.render();
+        };
+        await service.syncRepository({
+            owner: target.owner,
+            repo: target.repo,
+            onProgress: reporter,
+        });
+        await service.embedRepository({
+            owner: target.owner,
+            repo: target.repo,
+            onProgress: reporter,
+        });
+        service.clusterRepository({
+            owner: target.owner,
+            repo: target.repo,
+            onProgress: reporter,
+        });
+        writeTuiRepositoryPreference(service.config, {
+            owner: target.owner,
+            repo: target.repo,
+            minClusterSize: 1,
+            sortMode: 'recent',
+        });
+        log?.log('[setup] initial setup complete');
+        return true;
+    }
+    catch (error) {
+        log?.log(`[setup] failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export function parseOwnerRepoValue(value) {
+    const parts = value.trim().split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        return null;
+    }
+    return { owner: parts[0], repo: parts[1] };
+}
+function formatActivityTimestamp(now = new Date()) {
+    return now.toISOString().slice(11, 19);
+}
+function parseDateOrNull(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+function formatAge(diffMs) {
+    const safeDiffMs = Math.max(0, diffMs);
+    const minuteMs = 60_000;
+    const hourMs = 60 * minuteMs;
+    const dayMs = 24 * hourMs;
+    if (safeDiffMs < hourMs) {
+        return `${Math.max(1, Math.floor(safeDiffMs / minuteMs))}m`;
+    }
+    if (safeDiffMs < dayMs) {
+        return `${Math.floor(safeDiffMs / hourMs)}h`;
+    }
+    if (safeDiffMs < 14 * dayMs) {
+        return `${Math.floor(safeDiffMs / dayMs)}d`;
+    }
+    return `${Math.floor(safeDiffMs / dayMs)}d`;
+}
+function formatRelativeTime(value, now = new Date()) {
+    if (!value)
+        return 'never';
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return value;
+    const diffMs = Math.max(0, now.getTime() - parsed.getTime());
+    const minuteMs = 60_000;
+    const hourMs = 60 * minuteMs;
+    const dayMs = 24 * hourMs;
+    if (diffMs < hourMs) {
+        const minutes = Math.max(1, Math.floor(diffMs / minuteMs));
+        return `${minutes}m ago`;
+    }
+    if (diffMs < dayMs) {
+        return `${Math.floor(diffMs / hourMs)}h ago`;
+    }
+    if (diffMs < 14 * dayMs) {
+        return `${Math.floor(diffMs / dayMs)}d ago`;
+    }
+    return parsed.toISOString().slice(0, 10);
+}
+//# sourceMappingURL=app.js.map