@colmbus72/yeehaw 0.5.0 → 0.6.1

package/dist/views/IssuesView.js

@@ -1,135 +1,616 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
+// src/views/IssuesView.tsx
+import { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import TextInput from 'ink-text-input';
+import { join } from 'path';
+import { homedir } from 'os';
 import { Header } from '../components/Header.js';
 import { Panel } from '../components/Panel.js';
 import { List } from '../components/List.js';
 import { ScrollableMarkdown } from '../components/ScrollableMarkdown.js';
-import { parseGitHubUrl, fetchGitHubIssues, openIssueInBrowser, isGhCliAvailable, } from '../lib/github.js';
-export function IssuesView({ project, onBack }) {
+import { getProvider, } from '../lib/issues/index.js';
+import { saveProject } from '../lib/config.js';
+import { buildProjectContext } from '../lib/context.js';
+import { openIssueInBrowser } from '../lib/github.js';
+import { saveLinearApiKey, validateLinearApiKey, LINEAR_API_KEY_URL, clearLinearToken } from '../lib/auth/linear.js';
+// Expand ~ in paths to home directory
+function expandPath(path) {
+    if (path.startsWith('~/')) {
+        return join(homedir(), path.slice(2));
+    }
+    return path;
+}
+// Status indicator based on Linear state type
+function getStatusIndicator(stateType) {
+    switch (stateType) {
+        case 'backlog':
+        case 'triage':
+            return { char: '░', color: 'gray' };
+        case 'unstarted':
+            return { char: '░', color: 'gray' };
+        case 'started':
+            return { char: '▒', color: 'yellow' };
+        case 'completed':
+            return { char: '█', color: 'blue' };
+        case 'canceled':
+            return { char: '░', color: 'red' };
+        default:
+            return { char: ' ', color: 'gray' };
+    }
+}
+// Priority indicator: _ . : ! for low/med/high/urgent
+function getPriorityIndicator(priority) {
+    switch (priority) {
+        case 1: return '!'; // urgent
+        case 2: return ':'; // high
+        case 3: return '.'; // medium
+        case 4: return '_'; // low
+        default: return ' '; // no priority
+    }
+}
+// Get initials from name (first letter of first and last name)
+function getInitials(name) {
+    if (!name)
+        return '  ';
+    const parts = name.trim().split(/\s+/);
+    if (parts.length === 1) {
+        return parts[0].substring(0, 2).toUpperCase();
+    }
+    return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
+}
+export function IssuesView({ project, onBack, onOpenClaude }) {
+    const { stdout } = useStdout();
     const [focusedPanel, setFocusedPanel] = useState('list');
     const [selectedIndex, setSelectedIndex] = useState(0);
-    const [issues, setIssues] = useState([]);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    // Extract unique GitHub repos from local livestock
-    const getLocalRepos = () => {
-        const livestock = project.livestock || [];
-        const localLivestock = livestock.filter((l) => !l.barn && l.repo);
-        const seen = new Set();
-        const repos = [];
-        for (const l of localLivestock) {
-            if (!l.repo)
-                continue; // TypeScript narrows l.repo to string
-            const parsed = parseGitHubUrl(l.repo);
-            if (parsed) {
-                const key = `${parsed.owner}/${parsed.repo}`;
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    repos.push({ ...parsed, name: l.name });
-                }
-            }
-        }
-        return repos;
-    };
-    // Fetch issues on mount
-    useEffect(() => {
-        const loadIssues = () => {
-            setLoading(true);
-            setError(null);
-            if (!isGhCliAvailable()) {
-                setError('GitHub CLI (gh) not found or not authenticated. Run: gh auth login');
-                setLoading(false);
-                return;
+    const [viewState, setViewState] = useState({ type: 'loading' });
+    const [linearProvider, setLinearProvider] = useState(null);
+    const [apiKeyInput, setApiKeyInput] = useState('');
+    // Calculate dynamic height for ScrollableMarkdown based on terminal size
+    // Layout: Header(3) + FilterInfo(1) + PanelBorders(2) + PanelTitle(1) + PanelHints(1) + Padding(2) = ~10 lines overhead
+    const terminalHeight = stdout?.rows ?? 24;
+    const panelContentHeight = Math.max(8, terminalHeight - 10);
+    // Filter state for Linear
+    const [cycles, setCycles] = useState([]);
+    const [assignees, setAssignees] = useState([]);
+    const [currentFilter, setCurrentFilter] = useState({
+        stateType: ['backlog', 'unstarted', 'started'], // Default to open issues
+        sortBy: 'priority',
+        sortDirection: 'desc',
+    });
+    const [filterInitialized, setFilterInitialized] = useState(false);
+    // Filter UI state
+    const [filterField, setFilterField] = useState('assignee');
+    const [filterSelectedIndex, setFilterSelectedIndex] = useState(0);
+    // Team name for display
+    const [teamName, setTeamName] = useState();
+    // Cached current user ID for filter
+    const [currentUserId, setCurrentUserId] = useState(null);
+    // Track if user explicitly selected "Me" filter (separate from actual ID)
+    // Default to true since we want "assigned to me" as the default filter
+    const [filterByMe, setFilterByMe] = useState(true);
+    const loadIssues = useCallback(async (filter) => {
+        setViewState({ type: 'loading' });
+        const provider = getProvider(project);
+        if (!provider) {
+            setViewState({ type: 'disabled' });
+            return;
+        }
+        // Check authentication
+        const isAuthed = await provider.isAuthenticated();
+        if (!isAuthed) {
+            setViewState({ type: 'not-authenticated', providerType: provider.type });
+            if (provider.type === 'linear') {
+                setLinearProvider(provider);
             }
-            const repos = getLocalRepos();
-            if (repos.length === 0) {
-                setError('No GitHub repos found in local livestock');
-                setLoading(false);
-                return;
+            return;
+        }
+        // For Linear, check if team selection is needed
+        if (provider.type === 'linear') {
+            const linearProv = provider;
+            setLinearProvider(linearProv);
+            if (linearProv.needsTeamSelection()) {
+                try {
+                    const teams = await linearProv.fetchTeams();
+                    setViewState({ type: 'select-team', teams });
+                    return;
+                }
+                catch (err) {
+                    setViewState({ type: 'error', message: `Failed to fetch teams: ${err}` });
+                    return;
+                }
             }
-            const allIssues = [];
-            for (const repo of repos) {
-                const repoIssues = fetchGitHubIssues(repo.owner, repo.repo);
-                for (const issue of repoIssues) {
-                    allIssues.push({
-                        ...issue,
-                        repoName: repo.name,
-                        fullRepo: `${repo.owner}/${repo.repo}`,
-                    });
-                }
-            }
-            // Sort by updated date (most recent first)
-            allIssues.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-            setIssues(allIssues);
-            setLoading(false);
-        };
+            // Set team name from provider (loaded from config)
+            setTeamName(linearProv.getTeamName());
+            // Initialize default filter (current cycle, assigned to me)
+            if (!filterInitialized) {
+                try {
+                    // Fetch cycles, assignees, and user ID in parallel
+                    const [fetchedCycles, fetchedAssignees, userId] = await Promise.all([
+                        linearProv.fetchCycles(),
+                        linearProv.fetchAssignees(),
+                        linearProv.getCurrentUserId(),
+                    ]);
+                    setCycles(fetchedCycles);
+                    setAssignees(fetchedAssignees);
+                    setCurrentUserId(userId);
+                    // Set default filter: current cycle, assigned to me, open issues
+                    const activeCycleId = linearProv.getActiveCycleId();
+                    const defaultFilter = {
+                        cycleId: activeCycleId,
+                        stateType: ['backlog', 'unstarted', 'started'],
+                        sortBy: 'priority',
+                        sortDirection: 'desc',
+                    };
+                    // Only add assigneeId if we have a valid user ID
+                    if (userId) {
+                        defaultFilter.assigneeId = userId;
+                        setFilterByMe(true);
+                    }
+                    else {
+                        // Couldn't get user ID, so can't filter by "me"
+                        setFilterByMe(false);
+                    }
+                    setCurrentFilter(defaultFilter);
+                    setFilterInitialized(true);
+                    filter = defaultFilter;
+                }
+                catch (err) {
+                    // Continue without filter if fetch fails
+                    setFilterInitialized(true);
+                }
+            }
+        }
+        // Fetch issues
+        try {
+            const issues = await provider.fetchIssues({
+                linearFilter: filter ?? currentFilter,
+            });
+            setViewState({ type: 'ready', issues });
+        }
+        catch (err) {
+            setViewState({ type: 'error', message: `Failed to fetch issues: ${err}` });
+        }
+    }, [project, currentFilter, filterInitialized]);
+    useEffect(() => {
         loadIssues();
-    }, [project]);
-    const selectedIssue = issues[selectedIndex];
+    }, []); // Only run once on mount
+    const selectedIssue = viewState.type === 'ready' ? viewState.issues[selectedIndex] : null;
+    // Handle API key submission
+    const handleApiKeySubmit = async () => {
+        if (!apiKeyInput.trim())
+            return;
+        setViewState({ type: 'linear-auth-validating' });
+        const isValid = await validateLinearApiKey(apiKeyInput.trim());
+        if (isValid) {
+            saveLinearApiKey(apiKeyInput.trim());
+            setApiKeyInput('');
+            loadIssues();
+        }
+        else {
+            setViewState({ type: 'error', message: 'Invalid API key. Please check and try again.' });
+        }
+    };
+    // Handle team selection
+    const selectTeam = async (team) => {
+        if (!linearProvider)
+            return;
+        linearProvider.setTeamId(team.id);
+        linearProvider.setTeamName(team.name);
+        setTeamName(team.name);
+        // Save team ID and name to project config
+        const updatedProject = {
+            ...project,
+            issueProvider: { type: 'linear', teamId: team.id, teamName: team.name },
+        };
+        saveProject(updatedProject);
+        // Continue with existing provider (don't call loadIssues which would create new provider from stale prop)
+        setViewState({ type: 'loading' });
+        try {
+            // Fetch cycles, assignees, and user ID
+            const [fetchedCycles, fetchedAssignees, userId] = await Promise.all([
+                linearProvider.fetchCycles(),
+                linearProvider.fetchAssignees(),
+                linearProvider.getCurrentUserId(),
+            ]);
+            setCycles(fetchedCycles);
+            setAssignees(fetchedAssignees);
+            setCurrentUserId(userId);
+            // Set default filter: current cycle, assigned to me, open issues
+            const activeCycleId = linearProvider.getActiveCycleId();
+            const defaultFilter = {
+                cycleId: activeCycleId,
+                stateType: ['backlog', 'unstarted', 'started'],
+                sortBy: 'priority',
+                sortDirection: 'desc',
+            };
+            // Only add assigneeId if we have a valid user ID
+            if (userId) {
+                defaultFilter.assigneeId = userId;
+                setFilterByMe(true);
+            }
+            else {
+                // Couldn't get user ID, so can't filter by "me"
+                setFilterByMe(false);
+            }
+            setCurrentFilter(defaultFilter);
+            setFilterInitialized(true);
+            // Fetch issues
+            const issues = await linearProvider.fetchIssues({ linearFilter: defaultFilter });
+            setViewState({ type: 'ready', issues });
+        }
+        catch (err) {
+            setViewState({ type: 'error', message: `Failed to load issues: ${err}` });
+        }
+    };
+    // Build Claude context for an issue (includes project context)
+    const buildClaudeContext = (issue) => {
+        const lines = [];
+        // Include project context first (wiki sections, summary, etc.)
+        const projectContext = buildProjectContext(project.name);
+        if (projectContext) {
+            lines.push(projectContext);
+            lines.push('');
+            lines.push('---');
+            lines.push('');
+        }
+        lines.push('You are working on the following issue:');
+        lines.push('');
+        lines.push(`Title: ${issue.title}`);
+        lines.push(`Identifier: ${issue.identifier}`);
+        lines.push(`State: ${issue.state}`);
+        lines.push(`Author: ${issue.author}`);
+        lines.push(`URL: ${issue.url}`);
+        if (issue.priority !== undefined && issue.priority > 0) {
+            const priorityNames = ['', 'Urgent', 'High', 'Medium', 'Low'];
+            lines.push(`Priority: ${priorityNames[issue.priority]}`);
+        }
+        if (issue.assignee) {
+            lines.push(`Assignee: ${issue.assignee.name}`);
+        }
+        if (issue.estimate !== undefined) {
+            lines.push(`Points: ${issue.estimate}`);
+        }
+        lines.push('');
+        lines.push('Description:');
+        lines.push(issue.body || '(No description provided)');
+        lines.push('');
+        if (issue.labels.length > 0) {
+            lines.push(`Labels: ${issue.labels.join(', ')}`);
+            lines.push('');
+        }
+        if (issue.comments.length > 0) {
+            lines.push('---');
+            lines.push('Comments:');
+            lines.push('');
+            for (const comment of issue.comments) {
+                const date = new Date(comment.createdAt).toLocaleDateString();
+                lines.push(`${comment.author} (${date}):`);
+                lines.push(comment.body);
+                lines.push('');
+                lines.push('---');
+            }
+        }
+        return lines.join('\n');
+    };
+    // Apply filter and reload
+    const applyFilter = (newFilter) => {
+        setCurrentFilter(newFilter);
+        setViewState({ type: 'loading' });
+        loadIssues(newFilter);
+    };
     // Handle input
     useInput((input, key) => {
+        // Don't intercept input during text input mode
+        if (viewState.type === 'linear-auth-input') {
+            if (key.escape) {
+                setApiKeyInput('');
+                setViewState({ type: 'not-authenticated', providerType: 'linear' });
+            }
+            return;
+        }
+        // Filter view navigation
+        if (viewState.type === 'filter') {
+            if (key.escape) {
+                loadIssues(currentFilter);
+                return;
+            }
+            // Tab: select current option AND move to next field
+            if (key.tab) {
+                // First, select the current option (without applying yet)
+                selectFilterOptionLocal(filterField, filterSelectedIndex);
+                // Then move to next field
+                const fields = ['assignee', 'cycle', 'status', 'sort'];
+                const currentIndex = fields.indexOf(filterField);
+                setFilterField(fields[(currentIndex + 1) % fields.length]);
+                setFilterSelectedIndex(0);
+                return;
+            }
+            // Navigate options with j/k
+            if (input === 'j' || key.downArrow) {
+                const options = getFilterOptions(filterField);
+                setFilterSelectedIndex((prev) => Math.min(prev + 1, options.length - 1));
+                return;
+            }
+            if (input === 'k' || key.upArrow) {
+                setFilterSelectedIndex((prev) => Math.max(prev - 1, 0));
+                return;
+            }
+            // Enter: select current option, apply filter, and exit
+            if (key.return) {
+                const newFilter = selectFilterOptionLocal(filterField, filterSelectedIndex);
+                applyFilter(newFilter);
+                return;
+            }
+            return;
+        }
         if (key.escape) {
             onBack();
             return;
         }
-        // Tab to switch focus between panels
+        // Handle auth prompt - press Enter to start API key input
+        if (viewState.type === 'not-authenticated' && viewState.providerType === 'linear') {
+            if (key.return) {
+                setViewState({ type: 'linear-auth-input' });
+            }
+            return;
+        }
+        // Handle error state - 'r' to retry, 'a' to re-authenticate
+        if (viewState.type === 'error') {
+            if (input === 'r') {
+                loadIssues();
+                return;
+            }
+            if (input === 'a') {
+                clearLinearToken();
+                setViewState({ type: 'linear-auth-input' });
+                return;
+            }
+            return;
+        }
+        // In ready state
+        if (viewState.type !== 'ready')
+            return;
+        // Tab to switch focus
         if (key.tab) {
             setFocusedPanel((prev) => (prev === 'list' ? 'details' : 'list'));
             return;
         }
         // Refresh issues
         if (input === 'r') {
-            setLoading(true);
-            setError(null);
-            // Trigger re-fetch by updating a dependency
-            const repos = getLocalRepos();
-            const allIssues = [];
-            for (const repo of repos) {
-                const repoIssues = fetchGitHubIssues(repo.owner, repo.repo);
-                for (const issue of repoIssues) {
-                    allIssues.push({
-                        ...issue,
-                        repoName: repo.name,
-                        fullRepo: `${repo.owner}/${repo.repo}`,
-                    });
-                }
-            }
-            allIssues.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-            setIssues(allIssues);
-            setSelectedIndex(0);
-            setLoading(false);
+            loadIssues(currentFilter);
             return;
         }
-        // Open in browser
-        if (input === 'o' && selectedIssue) {
-            openIssueInBrowser(selectedIssue.url);
+        // Open filter (Linear only)
+        if (input === 'f' && project.issueProvider?.type === 'linear') {
+            setViewState({ type: 'filter' });
+            setFilterField('assignee');
+            setFilterSelectedIndex(0);
             return;
         }
-        // List navigation is handled by the List component via controlled selection
     });
-    // Truncate title if too long
+    // Get filter options for current field
+    const getFilterOptions = (field) => {
+        switch (field) {
+            case 'assignee':
+                return [
+                    { id: '__me__', label: 'Assigned to me' },
+                    { id: '__any__', label: 'Anyone' },
+                    { id: '__none__', label: 'Unassigned' },
+                    ...assignees.map((a) => ({ id: a.id, label: a.name })),
+                ];
+            case 'cycle':
+                return [
+                    { id: '__any__', label: 'Any cycle' },
+                    ...cycles.map((c) => ({ id: c.id, label: c.name })),
+                ];
+            case 'status':
+                return [
+                    { id: '__open__', label: 'Open (backlog, unstarted, started)' },
+                    { id: '__all__', label: 'All statuses' },
+                    { id: 'backlog', label: 'Backlog' },
+                    { id: 'unstarted', label: 'Todo' },
+                    { id: 'started', label: 'In Progress' },
+                    { id: 'completed', label: 'Done' },
+                    { id: 'canceled', label: 'Canceled' },
+                ];
+            case 'sort':
+                return [
+                    { id: 'priority_desc', label: 'Priority (high first)' },
+                    { id: 'priority_asc', label: 'Priority (low first)' },
+                    { id: 'updatedAt', label: 'Recently updated' },
+                    { id: 'createdAt', label: 'Recently created' },
+                ];
+            default:
+                return [];
+        }
+    };
+    // Select a filter option locally (without fetching) - used by Tab
+    // Returns the new filter for immediate use (since setState is async)
+    const selectFilterOptionLocal = (field, index) => {
+        const options = getFilterOptions(field);
+        const option = options[index];
+        if (!option)
+            return currentFilter;
+        const newFilter = { ...currentFilter };
+        switch (field) {
+            case 'assignee':
+                if (option.id === '__me__') {
+                    // Only set if we have a valid user ID
+                    if (currentUserId) {
+                        newFilter.assigneeId = currentUserId;
+                    }
+                    setFilterByMe(true);
+                }
+                else if (option.id === '__any__') {
+                    delete newFilter.assigneeId;
+                    setFilterByMe(false);
+                }
+                else if (option.id === '__none__') {
+                    newFilter.assigneeId = null;
+                    setFilterByMe(false);
+                }
+                else {
+                    newFilter.assigneeId = option.id;
+                    setFilterByMe(false);
+                }
+                break;
+            case 'cycle':
+                if (option.id === '__any__') {
+                    delete newFilter.cycleId;
+                }
+                else {
+                    newFilter.cycleId = option.id;
+                }
+                break;
+            case 'status':
+                if (option.id === '__open__') {
+                    newFilter.stateType = ['backlog', 'unstarted', 'started'];
+                }
+                else if (option.id === '__all__') {
+                    delete newFilter.stateType;
+                }
+                else {
+                    newFilter.stateType = option.id;
+                }
+                break;
+            case 'sort':
+                if (option.id === 'priority_desc') {
+                    newFilter.sortBy = 'priority';
+                    newFilter.sortDirection = 'desc';
+                }
+                else if (option.id === 'priority_asc') {
+                    newFilter.sortBy = 'priority';
+                    newFilter.sortDirection = 'asc';
+                }
+                else {
+                    newFilter.sortBy = option.id;
+                    delete newFilter.sortDirection;
+                }
+                break;
+        }
+        setCurrentFilter(newFilter);
+        return newFilter;
+    };
+    // Select a filter option and apply (fetch) - used by Enter
+    const selectFilterOption = async (field, index) => {
+        const options = getFilterOptions(field);
+        const option = options[index];
+        if (!option)
+            return;
+        const newFilter = { ...currentFilter };
+        switch (field) {
+            case 'assignee':
+                if (option.id === '__me__') {
+                    // Use cached currentUserId or fetch it
+                    const userId = currentUserId || await linearProvider?.getCurrentUserId();
+                    if (userId) {
+                        newFilter.assigneeId = userId;
+                        setCurrentUserId(userId); // Cache it if we just fetched
+                    }
+                    setFilterByMe(true);
+                }
+                else if (option.id === '__any__') {
+                    delete newFilter.assigneeId;
+                    setFilterByMe(false);
+                }
+                else if (option.id === '__none__') {
+                    newFilter.assigneeId = null;
+                    setFilterByMe(false);
+                }
+                else {
+                    newFilter.assigneeId = option.id;
+                    setFilterByMe(false);
+                }
+                break;
+            case 'cycle':
+                if (option.id === '__any__') {
+                    delete newFilter.cycleId;
+                }
+                else {
+                    newFilter.cycleId = option.id;
+                }
+                break;
+            case 'status':
+                if (option.id === '__open__') {
+                    newFilter.stateType = ['backlog', 'unstarted', 'started'];
+                }
+                else if (option.id === '__all__') {
+                    delete newFilter.stateType;
+                }
+                else {
+                    newFilter.stateType = option.id;
+                }
+                break;
+            case 'sort':
+                if (option.id === 'priority_desc') {
+                    newFilter.sortBy = 'priority';
+                    newFilter.sortDirection = 'desc';
+                }
+                else if (option.id === 'priority_asc') {
+                    newFilter.sortBy = 'priority';
+                    newFilter.sortDirection = 'asc';
+                }
+                else {
+                    newFilter.sortBy = option.id;
+                    delete newFilter.sortDirection;
+                }
+                break;
+        }
+        applyFilter(newFilter);
+    };
+    // Handle opening Claude for an issue (called from row action)
+    const handleOpenClaude = (issue) => {
+        if (!onOpenClaude)
+            return;
+        let workingDir;
+        if (issue.source.type === 'github') {
+            workingDir = issue.source.livestockPath || project.path;
+        }
+        else {
+            workingDir = project.path;
+        }
+        // Expand ~ to home directory and fallback to cwd if empty
+        if (workingDir) {
+            workingDir = expandPath(workingDir);
+        }
+        else {
+            workingDir = process.cwd();
+        }
+        const context = buildClaudeContext(issue);
+        onOpenClaude(workingDir, context);
+    };
     const truncate = (str, maxLen) => {
         if (str.length <= maxLen)
             return str;
         return str.slice(0, maxLen - 1) + '…';
     };
-    // Build list items - put repo tag as prefix, truncate long titles
-    const issueItems = issues.map((issue, i) => ({
-        id: String(i),
-        label: `[${issue.repoName}] #${issue.number} ${truncate(issue.title, 35)}`,
-        status: issue.state === 'open' ? 'active' : 'inactive',
-    }));
-    // Build issue details markdown
+    // Build issue details with better layout
     const buildIssueDetails = (issue) => {
         const lines = [];
-        lines.push(`**State:** ${issue.state}`);
-        lines.push(`**Author:** @${issue.author}`);
-        lines.push(`**Repo:** ${issue.fullRepo}`);
+        // Metadata grid
+        if (issue.source.type === 'github') {
+            lines.push(`**Repo:** ${issue.source.repo}  •  **Livestock:** ${issue.source.livestockName}`);
+        }
+        lines.push(`**State:** ${issue.state}  •  **Author:** ${issue.author}`);
+        if (issue.priority !== undefined && issue.priority > 0) {
+            const priorityNames = ['', 'Urgent', 'High', 'Medium', 'Low'];
+            const priorityLine = `**Priority:** ${priorityNames[issue.priority]}`;
+            const pointsLine = issue.estimate !== undefined ? `  •  **Points:** ${issue.estimate}` : '';
+            lines.push(priorityLine + pointsLine);
+        }
+        else if (issue.estimate !== undefined) {
+            lines.push(`**Points:** ${issue.estimate}`);
+        }
+        if (issue.assignee) {
+            lines.push(`**Assignee:** ${issue.assignee.name}`);
+        }
+        if (issue.cycle) {
+            lines.push(`**Cycle:** ${issue.cycle.name}`);
+        }
         if (issue.labels.length > 0) {
             lines.push(`**Labels:** ${issue.labels.join(', ')}`);
         }
-        lines.push(`**Comments:** ${issue.commentsCount}`);
         lines.push(`**Updated:** ${new Date(issue.updatedAt).toLocaleDateString()}`);
         lines.push('');
         lines.push('---');
@@ -140,18 +621,209 @@ export function IssuesView({ project, onBack }) {
         else {
             lines.push('*No description provided.*');
         }
+        // Add comments section
+        if (issue.comments.length > 0) {
+            lines.push('');
+            lines.push('---');
+            lines.push('');
+            lines.push(`**Comments (${issue.comments.length}):**`);
+            lines.push('');
+            for (const comment of issue.comments) {
+                const date = new Date(comment.createdAt).toLocaleDateString();
+                lines.push(`**${comment.author}** - ${date}`);
+                lines.push('');
+                lines.push(comment.body);
+                lines.push('');
+                lines.push('---');
+                lines.push('');
+            }
+        }
         return lines.join('\n');
     };
-    // Panel-specific hints (page-level hotkeys like r/o are in BottomBar)
-    const listHints = '';
-    const detailsHints = 'j/k scroll';
+    // Get subtitle for header
+    const getSubtitle = () => {
+        if (project.issueProvider?.type === 'linear' && teamName) {
+            return `Issues • ${teamName}`;
+        }
+        return 'Issues';
+    };
     // Loading state
-    if (loading) {
-        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsx(Box, { padding: 2, children: _jsx(Text, { children: "Loading issues..." }) })] }));
+    if (viewState.type === 'loading') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: getSubtitle(), color: project.color }), _jsx(Box, { padding: 2, children: _jsx(Text, { children: "Loading issues..." }) })] }));
+    }
+    // Disabled state
+    if (viewState.type === 'disabled') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsxs(Box, { padding: 2, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Issue tracking is disabled for this project." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press 'e' in the project view to enable it." }) })] })] }));
+    }
+    // Not authenticated - GitHub
+    if (viewState.type === 'not-authenticated' && viewState.providerType === 'github') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsxs(Box, { padding: 2, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "GitHub CLI not authenticated" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Run this command in your terminal:" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", children: "  gh auth login" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Then return here and the issues will load." }) })] })] }));
+    }
+    // Not authenticated - Linear (prompt to enter key)
+    if (viewState.type === 'not-authenticated' && viewState.providerType === 'linear') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsxs(Box, { padding: 2, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Linear authentication required" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "You need a Personal API Key from Linear." }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Create one at: ", _jsx(Text, { color: "cyan", children: LINEAR_API_KEY_URL })] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to paste your API key" }) })] })] }));
+    }
+    // Linear API key input
+    if (viewState.type === 'linear-auth-input') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsxs(Box, { padding: 2, flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "Enter Linear API Key" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Paste your Personal API Key from Linear:" }) }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "API Key: " }), _jsx(TextInput, { value: apiKeyInput, onChange: setApiKeyInput, onSubmit: handleApiKeySubmit, mask: "*" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: submit, Esc: cancel" }) })] })] }));
+    }
+    // Linear validating
+    if (viewState.type === 'linear-auth-validating') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsx(Box, { padding: 2, flexDirection: "column", children: _jsx(Text, { children: "Validating API key..." }) })] }));
+    }
+    // Team selection
+    if (viewState.type === 'select-team') {
+        const teamItems = viewState.teams.map((team) => ({
+            id: team.id,
+            label: `${team.name} (${team.key})`,
+            status: 'active',
+        }));
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsxs(Box, { padding: 2, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "yellow", children: "Select a Linear team" }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Which team's issues should be shown?" }) }), _jsx(List, { items: teamItems, focused: true, onSelect: (item) => {
+                                const team = viewState.teams.find((t) => t.id === item.id);
+                                if (team)
+                                    selectTeam(team);
+                            } })] })] }));
+    }
+    // Filter view
+    if (viewState.type === 'filter') {
+        const fields = [
+            { key: 'assignee', label: 'Assignee' },
+            { key: 'cycle', label: 'Cycle' },
+            { key: 'status', label: 'Status' },
+            { key: 'sort', label: 'Sort by' },
+        ];
+        const currentOptions = getFilterOptions(filterField);
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: getSubtitle(), color: project.color }), _jsxs(Box, { paddingX: 2, paddingY: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Filter Issues" }), _jsx(Box, { marginTop: 1, gap: 2, children: fields.map((f) => (_jsx(Text, { color: filterField === f.key ? 'cyan' : 'gray', children: filterField === f.key ? `[${f.label}]` : f.label }, f.key))) }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: currentOptions.map((opt, i) => (_jsxs(Text, { color: i === filterSelectedIndex ? 'green' : undefined, children: [i === filterSelectedIndex ? '▸ ' : '  ', opt.label] }, opt.id))) }), _jsx(Box, { marginTop: 2, children: _jsx(Text, { dimColor: true, children: "Tab: switch field \u2022 j/k: navigate \u2022 Enter: select \u2022 Esc: cancel" }) })] })] }));
     }
     // Error state
-    if (error) {
-        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsx(Box, { padding: 2, flexDirection: "column", children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })] }));
+    if (viewState.type === 'error') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: getSubtitle(), color: project.color }), _jsxs(Box, { padding: 2, flexDirection: "column", children: [_jsxs(Text, { color: "red", children: ["Error: ", viewState.message] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press 'r' to retry, 'a' to re-authenticate" }) })] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: "Issues", color: project.color }), _jsxs(Box, { flexGrow: 1, paddingX: 1, gap: 2, children: [_jsx(Panel, { title: "Issues", focused: focusedPanel === 'list', width: "40%", hints: listHints, children: issueItems.length > 0 ? (_jsx(List, { items: issueItems, focused: focusedPanel === 'list', selectedIndex: selectedIndex, onSelectionChange: setSelectedIndex })) : (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "No open issues" }) })) }), _jsx(Panel, { title: selectedIssue ? `#${selectedIssue.number} ${selectedIssue.title}` : 'Details', focused: focusedPanel === 'details', width: "60%", hints: detailsHints, children: selectedIssue ? (_jsx(ScrollableMarkdown, { focused: focusedPanel === 'details', height: 20, children: buildIssueDetails(selectedIssue) })) : (_jsx(Text, { dimColor: true, children: "Select an issue to view details" })) })] })] }));
+    // Ready state - show issues
+    if (viewState.type !== 'ready') {
+        return null;
+    }
+    // Row-level actions for issues
+    const issueActions = onOpenClaude
+        ? [{ key: 'c', label: 'claude' }, { key: 'o', label: 'open' }]
+        : [{ key: 'o', label: 'open' }];
+    const isLinear = project.issueProvider?.type === 'linear';
+    const issueItems = viewState.issues.map((issue, i) => {
+        let label;
+        if (isLinear) {
+            // Linear: status indicator + priority + identifier + title + assignee + points
+            const status = getStatusIndicator(issue.stateType);
+            const priority = getPriorityIndicator(issue.priority);
+            const initials = getInitials(issue.assignee?.name);
+            const points = issue.estimate !== undefined ? `${issue.estimate}p` : '';
+            // Format: ▒! ENG-123 Issue title here                CD 2p
+            const titleMaxLen = 32;
+            const truncatedTitle = truncate(issue.title, titleMaxLen);
+            label = `${priority} ${issue.identifier} ${truncatedTitle}`;
+            // Add assignee and points at the end
+            const suffix = [initials, points].filter(Boolean).join(' ');
+            if (suffix) {
+                // Pad to align
+                const padding = Math.max(0, 50 - label.length - suffix.length);
+                label = label + ' '.repeat(padding) + suffix;
+            }
+            return {
+                id: String(i),
+                label,
+                actions: issueActions,
+                prefix: _jsx(Text, { color: status.color, children: status.char }),
+            };
+        }
+        else {
+            // GitHub: [livestock] identifier title
+            const sourceTag = issue.source.type === 'github' ? issue.source.livestockName : '';
+            label = `[${sourceTag}] ${issue.identifier} ${truncate(issue.title, 35)}`;
+            return {
+                id: String(i),
+                label,
+                actions: issueActions,
+            };
+        }
+    });
+    // Build current filter description
+    const getFilterDescription = () => {
+        if (!isLinear)
+            return '';
+        const parts = [];
+        // Assignee - check explicitly for the different states
+        // assigneeId can be: string (specific user), null (unassigned), or undefined (anyone)
+        if (currentFilter.assigneeId === null) {
+            parts.push('Unassigned');
+        }
+        else if (filterByMe) {
+            // User explicitly selected "Me" filter
+            parts.push('Me');
+        }
+        else if (currentFilter.assigneeId !== undefined && currentFilter.assigneeId !== '') {
+            // Has a specific assignee ID (not "me")
+            const assignee = assignees.find((a) => a.id === currentFilter.assigneeId);
+            parts.push(assignee?.name ?? 'Assigned');
+        }
+        else {
+            // undefined or empty string means anyone
+            parts.push('Anyone');
+        }
+        // Cycle
+        if (currentFilter.cycleId) {
+            const cycle = cycles.find((c) => c.id === currentFilter.cycleId);
+            parts.push(cycle?.name ?? 'Cycle');
+        }
+        else {
+            parts.push('Any cycle');
+        }
+        // Status
+        if (currentFilter.stateType) {
+            const stateType = currentFilter.stateType;
+            if (Array.isArray(stateType)) {
+                // Check if it's the "open" preset
+                const isOpenPreset = stateType.length === 3 &&
+                    stateType.includes('backlog') &&
+                    stateType.includes('unstarted') &&
+                    stateType.includes('started');
+                parts.push(isOpenPreset ? 'Open' : stateType.join(', '));
+            }
+            else {
+                // Single status
+                const statusLabels = {
+                    backlog: 'Backlog',
+                    unstarted: 'Todo',
+                    started: 'In Progress',
+                    completed: 'Done',
+                    canceled: 'Canceled',
+                };
+                parts.push(statusLabels[stateType] ?? stateType);
+            }
+        }
+        else {
+            parts.push('All statuses');
+        }
+        // Sort
+        if (currentFilter.sortBy === 'priority') {
+            parts.push(currentFilter.sortDirection === 'asc' ? '↑Priority' : '↓Priority');
+        }
+        else if (currentFilter.sortBy === 'createdAt') {
+            parts.push('Recent');
+        }
+        else if (currentFilter.sortBy === 'updatedAt') {
+            parts.push('Updated');
+        }
+        return parts.join(' • ');
+    };
+    const detailsHints = 'j/k scroll';
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Header, { text: project.name, subtitle: getSubtitle(), color: project.color }), isLinear && (_jsxs(Box, { paddingX: 2, children: [_jsx(Text, { dimColor: true, children: "Showing: " }), _jsx(Text, { color: "cyan", children: getFilterDescription() }), _jsxs(Text, { dimColor: true, children: [" (", viewState.issues.length, ")"] })] })), _jsxs(Box, { flexGrow: 1, flexShrink: 1, paddingX: 1, gap: 2, overflow: "hidden", children: [_jsx(Panel, { title: "Issues", focused: focusedPanel === 'list', width: "45%", children: issueItems.length > 0 ? (_jsx(List, { items: issueItems, focused: focusedPanel === 'list', selectedIndex: selectedIndex, onSelectionChange: setSelectedIndex, onAction: (item, actionKey) => {
+                                const issue = viewState.issues[parseInt(item.id, 10)];
+                                if (!issue)
+                                    return;
+                                if (actionKey === 'c') {
+                                    handleOpenClaude(issue);
+                                }
+                                else if (actionKey === 'o') {
+                                    openIssueInBrowser(issue.url);
+                                }
+                            } })) : (_jsx(Text, { dimColor: true, children: "No issues match the current filter" })) }), _jsx(Panel, { title: selectedIssue ? `${selectedIssue.identifier} ${truncate(selectedIssue.title, 30)}` : 'Details', focused: focusedPanel === 'details', width: "55%", hints: detailsHints, children: selectedIssue ? (_jsx(ScrollableMarkdown, { focused: focusedPanel === 'details', height: panelContentHeight, children: buildIssueDetails(selectedIssue) })) : (_jsx(Text, { dimColor: true, children: "Select an issue to view details" })) })] })] }));
 }