jira-pilot 2.1.2 → 2.2.0

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);
+}