jira-pilot 2.1.2 → 2.1.3

package/src/tui/screens/IssueList.tsx

@@ -0,0 +1,116 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SpinnerOriginal from 'ink-spinner';
+const Spinner = SpinnerOriginal as any;
+import { api } from '../../services/api-service.js';
+import IssueDetail from './IssueDetail.js';
+
+export default function IssueList() {
+    const [loading, setLoading] = useState(true);
+    const [issues, setIssues] = useState<any[]>([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [selectedIssueKey, setSelectedIssueKey] = useState<string | null>(null);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        const fetchIssues = async () => {
+            try {
+                // Default search: Assigned to me or reported by me, unresolved
+                const results = await api.search('assignee = currentUser() OR reporter = currentUser() AND resolution = Unresolved order by updated DESC', 0, 20);
+                setIssues(results.issues);
+                setLoading(false);
+            } catch (err: any) {
+                setError(err.message);
+                setLoading(false);
+            }
+        };
+        fetchIssues();
+    }, []);
+
+    useInput((input, key) => {
+        if (selectedIssueKey) return; // Let Detail view handle input if active
+
+        if (key.upArrow) {
+            setSelectedIndex((prev: number) => Math.max(0, prev - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex((prev: number) => Math.min(issues.length - 1, prev + 1));
+        }
+        if (key.return) {
+            if (issues[selectedIndex]) {
+                setSelectedIssueKey(issues[selectedIndex].key);
+            }
+        }
+    });
+
+    if (selectedIssueKey) {
+        return <IssueDetail issueKey={selectedIssueKey} onBack={() => setSelectedIssueKey(null)} />;
+    }
+
+    if (loading) {
+        return (
+            <Box>
+                <Text color="green"><Spinner type="dots" /></Text>
+                <Text> Loading Issues...</Text>
+            </Box>
+        );
+    }
+    // ... rest of the file ...
+
+    if (error) {
+        return <Text color="red">Error: {error}</Text>;
+    }
+
+    if (issues.length === 0) {
+        return <Text>No issues found.</Text>;
+    }
+
+    // Pagination/Windowing logic could go here, for now just slice a window around selected
+    const windowSize = 10;
+    const start = Math.max(0, selectedIndex - Math.floor(windowSize / 2));
+    const end = Math.min(issues.length, start + windowSize);
+    const visibleIssues = issues.slice(start, end);
+
+    return (
+        <Box flexDirection="column">
+            <Box marginBottom={1}>
+                <Text bold underline>Issue Navigator ({issues.length})</Text>
+            </Box>
+
+            {visibleIssues.map((issue: any, index: number) => {
+                const globalIndex = start + index;
+                const isSelected = globalIndex === selectedIndex;
+                const key = issue.key;
+                const summary = issue.fields.summary;
+                const status = issue.fields.status.name;
+                const priority = issue.fields.priority.name;
+
+                return (
+                    <Box key={issue.id}>
+                        <Text color={isSelected ? 'green' : 'white'} bold={isSelected}>
+                            {isSelected ? '> ' : '  '}
+                        </Text>
+                        <Box width={12}>
+                            <Text color="cyan">{key}</Text>
+                        </Box>
+                        <Box width={12}>
+                            <Text color="yellow">{status}</Text>
+                        </Box>
+                        <Box width={10}>
+                            <Text color="magenta">{priority}</Text>
+                        </Box>
+                        <Box flexGrow={1}>
+                            <Text wrap="truncate-end">{summary}</Text>
+                        </Box>
+                    </Box>
+                );
+            })}
+
+            <Box marginTop={1} borderStyle="single" borderColor="gray">
+                <Text color="gray">
+                    Selected: {issues[selectedIndex]?.key} - {issues[selectedIndex]?.fields?.summary}
+                </Text>
+            </Box>
+        </Box>
+    );
+}

package/src/tui/screens/KanbanBoard.tsx

@@ -0,0 +1,133 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SpinnerOriginal from 'ink-spinner';
+const Spinner = SpinnerOriginal as any;
+import { api } from '../../services/api-service.js';
+
+interface KanbanBoardProps {
+    boardId: string;
+    onBack: () => void;
+}
+
+export default function KanbanBoard({ boardId, onBack }: KanbanBoardProps) {
+    const [loading, setLoading] = useState(true);
+    const [columns, setColumns] = useState<any[]>([]);
+    const [issues, setIssues] = useState<Record<string, any[]>>({});
+    const [activeColumnIndex, setActiveColumnIndex] = useState(0);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        const fetchData = async () => {
+            try {
+                // parallel fetch
+                const [config, boardIssues] = await Promise.all([
+                    api.agileGet(`/board/${boardId}/configuration`),
+                    api.agileGet(`/board/${boardId}/issue`)
+                ]);
+
+                const cols = config.columnConfig.columns;
+                setColumns(cols);
+
+                // Group issues by status/column
+                // This is simplified mapping logic. Jira statuses map to columns.
+                const issuesByStatus: Record<string, any[]> = {};
+                cols.forEach((col: any) => {
+                    issuesByStatus[col.name] = [];
+                });
+
+                boardIssues.issues.forEach((issue: any) => {
+                    const statusName = issue.fields.status.name;
+                    // Find which column this status belongs to involves checking config.columnConfig.columns[i].statuses
+                    // For now, let's just try to match column name or push to 'Other'
+                    let placed = false;
+                    for (const col of cols) {
+                        // Check if status in column statuses
+                        // config.columnConfig.columns structure: { name: 'To Do', statuses: [ { id: '10000', self: '...' } ] }
+                        if (col.statuses && col.statuses.some((s: any) => s.id === issue.fields.status.id)) {
+                            if (!issuesByStatus[col.name]) issuesByStatus[col.name] = [];
+                            issuesByStatus[col.name].push(issue);
+                            placed = true;
+                            break;
+                        }
+                    }
+                    if (!placed) {
+                        // fallback: try direct name match
+                        if (issuesByStatus[statusName]) {
+                            issuesByStatus[statusName].push(issue);
+                        }
+                    }
+                });
+
+                setIssues(issuesByStatus);
+                setLoading(false);
+            } catch (err: any) {
+                setError(err.message);
+                setLoading(false);
+            }
+        };
+        fetchData();
+    }, [boardId]);
+
+    useInput((input, key) => {
+        if (key.escape || input === 'b') {
+            onBack();
+        }
+        if (key.leftArrow) {
+            setActiveColumnIndex((prev: number) => Math.max(0, prev - 1));
+        }
+        if (key.rightArrow) {
+            setActiveColumnIndex((prev: number) => Math.min(columns.length - 1, prev + 1));
+        }
+    });
+
+    if (loading) {
+        return (
+            <Box>
+                <Text color="green"><Spinner type="dots" /></Text>
+                <Text> Loading Board...</Text>
+            </Box>
+        );
+    }
+
+    if (error) {
+        return <Text color="red">Error: {error}</Text>;
+    }
+
+    return (
+        <Box flexDirection="column" height="100%">
+            <Box marginBottom={1}>
+                <Text>Board View (Use ←/→ to switch columns, Esc to back)</Text>
+            </Box>
+
+            <Box flexDirection="row" flexGrow={1}>
+                {columns.map((col: any, index: number) => {
+                    const isActive = index === activeColumnIndex;
+                    const colIssues = issues[col.name] || [];
+
+                    return (
+                        <Box
+                            key={col.name}
+                            flexDirection="column"
+                            width={30}
+                            borderStyle={isActive ? 'double' : 'single'}
+                            borderColor={isActive ? 'green' : 'gray'}
+                            marginRight={1}
+                            paddingX={1}
+                        >
+                            <Box marginBottom={1} borderStyle="single" borderBottom={false} borderLeft={false} borderRight={false} borderTop={false}>
+                                <Text bold underline color={isActive ? 'green' : 'white'}>{col.name} ({colIssues.length})</Text>
+                            </Box>
+
+                            {colIssues.slice(0, 10).map((issue: any) => ( // Limit simplified list
+                                <Box key={issue.id} marginBottom={1}>
+                                    <Text color="cyan">{issue.key}</Text>
+                                    <Text wrap="truncate">{issue.fields.summary}</Text>
+                                </Box>
+                            ))}
+                        </Box>
+                    );
+                })}
+            </Box>
+        </Box>
+    );
+}

package/src/tui/utils/adf-render.ts

@@ -0,0 +1,30 @@
+
+export function renderADF(node: any): string {
+    if (!node) return '';
+    if (typeof node === 'string') return node;
+
+    // Handle text nodes
+    if (node.type === 'text') {
+        return node.text || '';
+    }
+
+    // Handle content arrays
+    if (node.content && Array.isArray(node.content)) {
+        return node.content.map(renderADF).join('');
+    }
+
+    // Handle specific block types (optional formatting)
+    switch (node.type) {
+        case 'paragraph':
+            return renderADF({ content: node.content }) + '\n';
+        case 'bulletList':
+        case 'orderedList':
+            return renderADF({ content: node.content });
+        case 'listItem':
+            return '• ' + renderADF({ content: node.content });
+        case 'hardBreak':
+            return '\n';
+        default:
+            return '';
+    }
+}

package/src/utils/error-handler.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { Ora } from 'ora';
+import { Spinner } from './spinner.js';
 
 /**
  * Standardized error handler for CLI commands.
@@ -9,7 +9,7 @@ import { Ora } from 'ora';
  * @param {Error} error - The error object
  * @param {string} [context] - Optional context (e.g., "Failed to list issues")
  */
-export function handleCommandError(spinner: Ora | null, error: any, context = 'Operation failed') {
+export function handleCommandError(spinner: Spinner | null, error: any, context = 'Operation failed') {
     // Handle user cancellation (Ctrl+C in enquirer)
     if (error === '' || (error && error.message === '')) {
         if (spinner) spinner.stop();

package/src/utils/http.ts

@@ -0,0 +1,128 @@
+
+import https from 'https';
+
+interface HelperConfig {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    validateStatus?: (status: number) => boolean;
+    httpsAgent?: https.Agent;
+}
+
+interface RequestConfig extends HelperConfig {
+    params?: Record<string, any>;
+}
+
+interface Response<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+
+export class HttpClient {
+    private defaults: HelperConfig;
+
+    constructor(defaults: HelperConfig = {}) {
+        this.defaults = defaults;
+    }
+
+    static create(config: HelperConfig = {}) {
+        return new HttpClient(config);
+    }
+
+    async request<T = any>(url: string, options: RequestInit & RequestConfig = {}): Promise<Response<T>> {
+        const baseURL = options.baseURL || this.defaults.baseURL || '';
+        const fullUrl = new URL(url.startsWith('http') ? url : `${baseURL}${url}`);
+
+        if (options.params) {
+            Object.entries(options.params).forEach(([key, value]) => {
+                if (value !== undefined) fullUrl.searchParams.append(key, String(value));
+            });
+        }
+
+        const headers = {
+            ...this.defaults.headers,
+            ...options.headers
+        } as Record<string, string>;
+
+        // Handle body for JSON
+        let body = options.body;
+        if (body && typeof body === 'object') {
+            const explicitContentType = headers['Content-Type'];
+            if (!explicitContentType || explicitContentType.includes('application/json')) {
+                if (!explicitContentType) {
+                    headers['Content-Type'] = 'application/json';
+                }
+                body = JSON.stringify(body);
+            }
+        }
+
+        const fetchOptions: RequestInit = {
+            method: options.method || 'GET',
+            headers,
+            body: body as BodyInit,
+            // Node native fetch doesn't support 'agent' directly in standard RequestInit 
+            // but we can pass it via 'dispatcher' in undici, or ignore if using global fetch.
+            // For simple usage we usually ignore httpsAgent unless strictly needed.
+        };
+
+        const response = await fetch(fullUrl.toString(), fetchOptions);
+
+        let data: any;
+        const contentType = response.headers.get('content-type');
+        const contentLength = response.headers.get('content-length');
+
+        if (response.status === 204 || (contentLength && parseInt(contentLength) === 0)) {
+            data = null;
+        } else if (contentType && contentType.includes('application/json')) {
+            try {
+                data = await response.json();
+            } catch (error) {
+                // If JSON parsing fails (e.g. empty body despite content-type), fallback to text or null
+                const text = await response.text();
+                try {
+                    data = JSON.parse(text);
+                } catch {
+                    data = text || null;
+                }
+            }
+        } else {
+            data = await response.text();
+        }
+
+        const res: Response<T> = {
+            data,
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries())
+        };
+
+        const validateStatus = options.validateStatus || this.defaults.validateStatus || ((s) => s >= 200 && s < 300);
+        if (!validateStatus(res.status)) {
+            const error: any = new Error(`Request failed with status ${res.status}`);
+            error.response = res;
+            error.status = res.status;
+            throw error;
+        }
+
+        return res;
+    }
+
+    async get<T = any>(url: string, config: RequestConfig = {}) {
+        return this.request<T>(url, { ...config, method: 'GET' });
+    }
+
+    async post<T = any>(url: string, data?: any, config: RequestConfig = {}) {
+        return this.request<T>(url, { ...config, method: 'POST', body: data });
+    }
+
+    async put<T = any>(url: string, data?: any, config: RequestConfig = {}) {
+        return this.request<T>(url, { ...config, method: 'PUT', body: data });
+    }
+
+    async delete<T = any>(url: string, config: RequestConfig = {}) {
+        return this.request<T>(url, { ...config, method: 'DELETE' });
+    }
+}
+
+export default HttpClient;

package/src/utils/spinner.ts

@@ -0,0 +1,87 @@
+export class Spinner {
+    private timer: NodeJS.Timeout | null = null;
+    private frameIndex = 0;
+    private frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    public text: string;
+
+    constructor(text: string | { text: string }) {
+        this.text = typeof text === 'string' ? text : (text?.text || '');
+    }
+
+    start(text?: string): Spinner {
+        if (text) this.text = text;
+        this.frameIndex = 0;
+        // Only start animation if TTY and not CI (basic check)
+        if (process.stdout.isTTY) {
+            this.timer = setInterval(() => {
+                const frame = this.frames[this.frameIndex];
+                this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+                this.write(`\r${frame} ${this.text}`);
+            }, 80);
+        } else {
+            console.log(this.text);
+        }
+        return this;
+    }
+
+    stop(): Spinner {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+            this.clearLine();
+        }
+        return this;
+    }
+
+    succeed(text?: string): Spinner {
+        this.stop();
+        const msg = text || this.text;
+        console.log(`${this.color('green', '✔')} ${msg}`);
+        return this;
+    }
+
+    fail(text?: string): Spinner {
+        this.stop();
+        const msg = text || this.text;
+        console.log(`${this.color('red', '✖')} ${msg}`);
+        return this;
+    }
+
+    info(text?: string): Spinner {
+        this.stop();
+        console.log(`${this.color('blue', 'ℹ')} ${text || this.text}`);
+        return this;
+    }
+
+    warn(text?: string): Spinner {
+        this.stop();
+        console.log(`${this.color('yellow', '⚠')} ${text || this.text}`);
+        return this;
+    }
+
+    private clearLine() {
+        if (process.stdout.isTTY) {
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+    }
+
+    private write(str: string) {
+        process.stdout.write(str);
+    }
+
+    private color(color: string, str: string): string {
+        const colors: any = {
+            green: '\x1b[32m',
+            red: '\x1b[31m',
+            blue: '\x1b[34m',
+            yellow: '\x1b[33m',
+            reset: '\x1b[0m'
+        };
+        return `${colors[color] || ''}${str}${colors.reset}`;
+    }
+}
+
+export default function ora(options: string | { text: string } = '') {
+    return new Spinner(options);
+}