jira-pilot 2.0.4 → 2.1.0

package/src/services/{ai-service.js → ai-service.ts}

@@ -4,10 +4,10 @@ import { getCredentials } from '../utils/config.js';
 export class AiService {
     constructor() { }
 
-    async generate(prompt) {
-        const { aiKey, aiProvider, aiEnabled } = getCredentials();
+    async generate(prompt: string): Promise<string> {
+        const { aiKey, aiProvider, enableAi } = getCredentials();
 
-        if (!aiEnabled) {
+        if (!enableAi) {
             throw new Error('AI features are disabled. Run "jira config ai enable" to enable.');
         }
 
@@ -29,7 +29,7 @@ export class AiService {
         }
     }
 
-    async reviewCode(diff, context) {
+    async reviewCode(diff: string, context: string): Promise<string> {
         const prompt = `Review the following code changes against the issue context.
 Issue Context: ${context}
 
@@ -47,7 +47,7 @@ Provide a concise code review. Focus on:
         return this.generate(prompt);
     }
 
-    async breakdownEpic(summary, description) {
+    async breakdownEpic(summary: string, description: string): Promise<any> {
         const prompt = `Break down the following Epic into child Stories and Tasks.
 Epic Summary: ${summary}
 Epic Description: ${description || 'N/A'}
@@ -60,7 +60,7 @@ Example: [{"type": "Story", "summary": "...", "description": "..."}]`;
         return JSON.parse(jsonStr);
     }
 
-    async generateStandup(yesterday, today) {
+    async generateStandup(yesterday: string, today: string): Promise<string> {
         const prompt = `Generate a daily standup update based on my Jira activity.
 Activity (Last 24h):
 ${yesterday}
@@ -77,7 +77,7 @@ Keep it concise and professional.`;
         return this.generate(prompt);
     }
 
-    async generateJql(query) {
+    async generateJql(query: string): Promise<string> {
         const prompt = `Convert the following natural language query into Jira JQL.
 Query: "${query}"
 
@@ -87,7 +87,7 @@ Today is ${new Date().toISOString().split('T')[0]}.`;
         return response.replace(/```/g, '').trim();
     }
 
-    async callOpenAI(key, prompt) {
+    async callOpenAI(key: string, prompt: string): Promise<string> {
         try {
             const response = await axios.post('https://api.openai.com/v1/chat/completions', {
                 model: 'gpt-4o',
@@ -97,12 +97,12 @@ Today is ${new Date().toISOString().split('T')[0]}.`;
                 headers: { 'Authorization': `Bearer ${key}` }
             });
             return response.data.choices[0].message.content;
-        } catch (e) {
+        } catch (e: any) {
             throw new Error(`OpenAI API Error: ${e.response?.data?.error?.message || e.message}`);
         }
     }
 
-    async callGemini(key, prompt) {
+    async callGemini(key: string, prompt: string): Promise<string> {
         try {
             // Gemini REST API — uses generativelanguage.googleapis.com
             const model = 'gemini-2.0-flash';
@@ -125,8 +125,8 @@ Today is ${new Date().toISOString().split('T')[0]}.`;
                 throw new Error('No response generated by Gemini.');
             }
 
-            return candidates[0].content.parts.map(p => p.text).join('');
-        } catch (e) {
+            return candidates[0].content.parts.map((p: any) => p.text).join('');
+        } catch (e: any) {
             if (e.response?.data?.error) {
                 throw new Error(`Gemini API Error: ${e.response.data.error.message}`);
             }
@@ -134,7 +134,7 @@ Today is ${new Date().toISOString().split('T')[0]}.`;
         }
     }
 
-    async callAnthropic(key, prompt) {
+    async callAnthropic(key: string, prompt: string): Promise<string> {
         try {
             // Anthropic Messages API
             const response = await axios.post('https://api.anthropic.com/v1/messages', {
@@ -150,10 +150,10 @@ Today is ${new Date().toISOString().split('T')[0]}.`;
             });
 
             return response.data.content
-                .filter(block => block.type === 'text')
-                .map(block => block.text)
+                .filter((block: any) => block.type === 'text')
+                .map((block: any) => block.text)
                 .join('');
-        } catch (e) {
+        } catch (e: any) {
             if (e.response?.data?.error) {
                 throw new Error(`Anthropic API Error: ${e.response.data.error.message}`);
             }

package/src/services/{api-service.js → api-service.ts}

@@ -3,10 +3,16 @@ import chalk from 'chalk';
 import { getCredentials } from '../utils/config.js';
 
 export class ApiService {
+    private client: any;
+    private agileClient: any;
+    private _domain: string | null = null;
+
     constructor() {
         this.init();
     }
 
+
+
     init() {
         const { jiraUrl, email, apiToken } = getCredentials();
 
@@ -42,7 +48,7 @@ export class ApiService {
         });
 
         // Shared response interceptor
-        const errorInterceptor = (error) => {
+        const errorInterceptor = (error: any) => {
             if (error.response) {
                 if (error.response.status === 401) {
                     console.error(chalk.red('Authentication failed. Please check your credentials using "jira config".'));
@@ -53,8 +59,8 @@ export class ApiService {
             return Promise.reject(error);
         };
 
-        this.client.interceptors.response.use(r => r, errorInterceptor);
-        this.agileClient.interceptors.response.use(r => r, errorInterceptor);
+        this.client.interceptors.response.use((r: any) => r, errorInterceptor);
+        this.agileClient.interceptors.response.use((r: any) => r, errorInterceptor);
     }
 
     /** @returns {string} The Jira domain URL */
@@ -73,39 +79,57 @@ export class ApiService {
 
     // ── Standard REST API v3 Methods ────────────────────────────────
 
-    async get(url, config = {}) {
+    async get(url: string, config: any = {}) {
         this.ensureClient();
         const response = await this.client.get(url, config);
         return response.data;
     }
 
-    async post(url, data, config = {}) {
+    async post(url: string, data: any, config: any = {}) {
         this.ensureClient();
         const response = await this.client.post(url, data, config);
         return response.data;
     }
 
-    async put(url, data, config = {}) {
+    async put(url: string, data: any, config: any = {}) {
         this.ensureClient();
         const response = await this.client.put(url, data, config);
         return response.data;
     }
 
-    async delete(url, config = {}) {
+    async delete(url: string, config: any = {}) {
         this.ensureClient();
         const response = await this.client.delete(url, config);
         return response.data;
     }
 
+    async upload(url: string, formData: any) {
+        this.ensureClient();
+        // Jira requires this header for attachments
+        const headers: any = {
+            'X-Atlassian-Token': 'no-check'
+        };
+
+        // If using 'form-data' package, it has getHeaders().
+        // If using native FormData, axios/adapter handles Content-Type + boundary.
+        if (formData.getHeaders) {
+            Object.assign(headers, formData.getHeaders());
+        }
+
+        const config = { headers };
+        const response = await this.client.post(url, formData, config);
+        return response.data;
+    }
+
     // ── Agile REST API v1 Methods ───────────────────────────────────
 
-    async agileGet(url, config = {}) {
+    async agileGet(url: string, config: any = {}) {
         this.ensureClient();
         const response = await this.agileClient.get(url, config);
         return response.data;
     }
 
-    async agilePost(url, data, config = {}) {
+    async agilePost(url: string, data: any, config: any = {}) {
         this.ensureClient();
         const response = await this.agileClient.post(url, data, config);
         return response.data;

package/src/services/config-service.ts

@@ -0,0 +1,21 @@
+import ConfigStore from '../utils/config-store.js';
+
+const config = new ConfigStore('jira-pilot');
+
+export class ConfigService {
+    static getConfig() {
+        return config.all;
+    }
+
+    static saveConfig(newConfig: any) {
+        config.all = newConfig;
+    }
+
+    static get(key: string) {
+        return config.get(key);
+    }
+
+    static set(key: string, value: any) {
+        config.set(key, value);
+    }
+}

package/src/types.ts

@@ -0,0 +1,68 @@
+export interface JiraIssue {
+    key: string;
+    fields: {
+        summary: string;
+        description?: any; // ADF
+        status: { name: string; id?: string };
+        priority?: { name: string; id?: string };
+        assignee?: { accountId: string; displayName: string; emailAddress?: string };
+        issuetype: { name: string; id?: string; subtask?: boolean };
+        created: string;
+        updated: string;
+        comment?: {
+            comments: Array<{
+                id: string;
+                body: string;
+                author: { displayName: string; accountId: string };
+                created: string;
+            }>;
+            total: number;
+        };
+        [key: string]: any;
+    };
+}
+
+export interface JiraProject {
+    key: string;
+    name: string;
+    id: string;
+    lead?: { displayName: string };
+    style?: string; // classic / next-gen
+    issueTypes?: Array<{ name: string; subtask?: boolean; id: string }>;
+}
+
+export interface JiraSprint {
+    id: number;
+    name: string;
+    state: 'active' | 'future' | 'closed';
+    startDate?: string;
+    endDate?: string;
+    originBoardId?: number;
+}
+
+export interface JiraBoard {
+    id: number;
+    name: string;
+    type: string;
+    location?: { projectId: number; displayName: string; projectKey: string };
+}
+
+export interface ConfigProfile {
+    jiraUrl: string;
+    email: string;
+    apiToken: string;
+    aiEnabled?: boolean; // Unified key
+    enableAi?: boolean;  // Legacy key support
+    aiProvider?: 'openai' | 'gemini' | 'anthropic';
+    aiKey?: string; // Legacy
+    aiConfig?: {
+        apiKey?: string;
+        model?: string;
+    };
+    githubToken?: string;
+}
+
+export interface GlobalConfig {
+    profiles: Record<string, ConfigProfile>;
+    currentProfile?: string;
+}

package/src/utils/{adf-parser.js → adf-parser.ts}

@@ -1,15 +1,15 @@
-export function parseADF(content) {
+export function parseADF(content: any) {
     if (!content) return '';
     if (typeof content === 'string') return content;
 
     if (content.type === 'doc') {
-        return content.content.map(node => parseNode(node)).join('\n');
+        return content.content.map((node: any) => parseNode(node)).join('\n');
     }
 
     return JSON.stringify(content);
 }
 
-function parseNode(node) {
+function parseNode(node: any): string {
     if (!node) return '';
 
     switch (node.type) {
@@ -22,28 +22,28 @@ function parseNode(node) {
         case 'orderedList':
             return parseList(node, '1.');
         case 'heading':
-            return `\n${'#'.repeat(node.attrs?.level || 1)} ${node.content.map(c => parseNode(c)).join('')}\n`;
+            return `\n${'#'.repeat(node.attrs?.level || 1)} ${node.content.map((c: any) => parseNode(c)).join('')}\n`;
         case 'codeBlock':
-            return `\n\`\`\`${node.attrs?.language || ''}\n${node.content.map(c => c.text).join('')}\n\`\`\`\n`;
+            return `\n\`\`\`${node.attrs?.language || ''}\n${node.content.map((c: any) => c.text).join('')}\n\`\`\`\n`;
         case 'blockquote':
-            return `> ${node.content.map(c => parseNode(c)).join('')}`;
+            return `> ${node.content.map((c: any) => parseNode(c)).join('')}`;
         default:
             if (node.content) {
-                return node.content.map(c => parseNode(c)).join('');
+                return node.content.map((c: any) => parseNode(c)).join('');
             }
             return ''; // Unknown node, skip or fallback
     }
 }
 
-function parseParagraph(node) {
+function parseParagraph(node: any) {
     if (!node.content) return '\n';
-    return node.content.map(c => parseNode(c)).join('') + '\n';
+    return node.content.map((c: any) => parseNode(c)).join('') + '\n';
 }
 
-function parseList(node, marker) {
+function parseList(node: any, marker: string) {
     if (!node.content) return '';
-    return node.content.map((item, index) => {
+    return node.content.map((item: any, index: number) => {
         const prefix = marker === '1.' ? `${index + 1}. ` : `${marker} `;
-        return `${prefix}${item.content.map(c => parseNode(c)).join('')}`;
+        return `${prefix}${item.content.map((c: any) => parseNode(c)).join('')}`;
     }).join('\n') + '\n';
 }

package/src/utils/config-store.ts

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+function getAppDataPath() {
+    if (process.platform === 'win32') {
+        return process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(os.homedir(), 'Library', 'Preferences');
+    }
+    return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+}
+
+class ConfigStore {
+    private dir: string;
+    private path: string;
+
+    constructor(projectName: string) {
+        this.dir = path.join(getAppDataPath(), projectName);
+        this.path = path.join(this.dir, 'config.json');
+        this.ensureDir();
+    }
+
+    ensureDir() {
+        if (!fs.existsSync(this.dir)) {
+            fs.mkdirSync(this.dir, { recursive: true });
+        }
+    }
+
+    load() {
+        try {
+            if (!fs.existsSync(this.path)) return {};
+            return JSON.parse(fs.readFileSync(this.path, 'utf8'));
+        } catch (e) {
+            return {};
+        }
+    }
+
+    save(data: any) {
+        this.ensureDir();
+        fs.writeFileSync(this.path, JSON.stringify(data, null, 4), 'utf8');
+    }
+
+    get(key?: string): any {
+        const data = this.load();
+        if (!key) return data;
+
+        // Support dot notation: profiles.work
+        const parts = key.split('.');
+        let current = data;
+        for (const part of parts) {
+            if (current === undefined || current === null) return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+
+    set(key: string, value: any): void {
+        const data = this.load();
+
+        const parts = key.split('.');
+        const last = parts.pop();
+        if (!last) return;
+
+        let current = data;
+        for (const part of parts) {
+            if (typeof current[part] !== 'object' || current[part] === null) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+
+        current[last] = value;
+        this.save(data);
+    }
+
+    delete(key: string): void {
+        const data = this.load();
+        const parts = key.split('.');
+        const last = parts.pop();
+        if (!last) return; // Should not happen
+
+        let current = data;
+        for (const part of parts) {
+            if (current === undefined || current === null) return; // Key doesn't exist
+            current = current[part];
+        }
+
+        if (current && typeof current === 'object') {
+            delete current[last];
+            this.save(data);
+        }
+    }
+
+    clear() {
+        this.save({});
+    }
+
+    get all() {
+        return this.load();
+    }
+
+    set all(data: any) {
+        this.save(data);
+    }
+}
+
+export default ConfigStore;

package/src/utils/{config.js → config.ts}

@@ -1,57 +1,30 @@
-import Conf from 'conf';
+import ConfigStore from './config-store.js';
+import { ConfigProfile } from '../types.js';
 
-const schema = {
-    jiraUrl: {
-        type: 'string',
-        format: 'url'
-    },
-    email: {
-        type: 'string',
-        format: 'email'
-    },
-    apiToken: {
-        type: 'string'
-    },
-    aiKey: {
-        type: 'string'
-    },
-    aiProvider: {
-        type: 'string',
-        default: 'openai'
-    },
-    aiEnabled: {
-        type: 'boolean',
-        default: false
-    },
-    githubToken: {
-        type: 'string'
-    }
-};
+const config = new ConfigStore('jira-pilot');
 
-const config = new Conf({
-    projectName: 'jira-pilot',
-    schema
-});
-
-export const getCredentials = () => {
+export const getCredentials = (): Partial<ConfigProfile> => {
     return {
         jiraUrl: config.get('jiraUrl'),
         email: config.get('email'),
         apiToken: config.get('apiToken'),
         aiKey: config.get('aiKey'),
         aiProvider: config.get('aiProvider'),
-        aiEnabled: config.get('aiEnabled'),
+        enableAi: config.get('aiEnabled'), // Map legacy key
         githubToken: config.get('githubToken')
     };
 };
 
-export const setCredentials = ({ jiraUrl, email, apiToken, aiKey, aiProvider, aiEnabled, githubToken }) => {
+export const setCredentials = ({ jiraUrl, email, apiToken, aiConfig, aiProvider, enableAi, githubToken }: Partial<ConfigProfile>) => {
     if (jiraUrl) config.set('jiraUrl', jiraUrl);
     if (email) config.set('email', email);
     if (apiToken) config.set('apiToken', apiToken);
-    if (aiKey) config.set('aiKey', aiKey);
+    if (aiConfig) {
+        if (aiConfig.apiKey) config.set('aiKey', aiConfig.apiKey);
+        config.set('aiConfig', aiConfig);
+    }
     if (aiProvider) config.set('aiProvider', aiProvider);
-    if (typeof aiEnabled !== 'undefined') config.set('aiEnabled', aiEnabled);
+    if (typeof enableAi !== 'undefined') config.set('enableAi', enableAi);
     if (githubToken) config.set('githubToken', githubToken);
 };
 
@@ -66,13 +39,13 @@ export const hasCredentials = () => {
 
 // ── Profile Management ──────────────────────────────────────────────
 
-export const saveProfile = (name) => {
+export const saveProfile = (name: string): void => {
     const creds = getCredentials();
     config.set(`profiles.${name}`, creds);
     config.set('activeProfile', name);
 };
 
-export const loadProfile = (name) => {
+export const loadProfile = (name: string): boolean => {
     const profile = config.get(`profiles.${name}`);
     if (!profile) return false;
     setCredentials(profile);
@@ -80,7 +53,7 @@ export const loadProfile = (name) => {
     return true;
 };
 
-export const deleteProfile = (name) => {
+export const deleteProfile = (name: string): void => {
     config.delete(`profiles.${name}`);
     if (config.get('activeProfile') === name) {
         config.delete('activeProfile');

package/src/utils/{error-handler.js → error-handler.ts}

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { Ora } from 'ora';
 
 /**
  * Standardized error handler for CLI commands.
@@ -8,7 +9,7 @@ import chalk from 'chalk';
  * @param {Error} error - The error object
  * @param {string} [context] - Optional context (e.g., "Failed to list issues")
  */
-export function handleCommandError(spinner, error, context = 'Operation failed') {
+export function handleCommandError(spinner: Ora | 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/{text-to-adf.js → text-to-adf.ts}

@@ -5,7 +5,7 @@
  * @param {string} text - Plain text string
  * @returns {object} ADF document node
  */
-export function textToADF(text) {
+export function textToADF(text: any) {
     if (!text || typeof text !== 'string') {
         return {
             type: 'doc',

package/src/utils/{validators.js → validators.ts}

@@ -8,7 +8,7 @@
  * @param {string} key - The issue key to validate.
  * @returns {{ valid: boolean, message?: string }}
  */
-export function validateIssueKey(key) {
+export function validateIssueKey(key: any): { valid: boolean; message?: string } {
     if (!key || typeof key !== 'string') {
         return { valid: false, message: 'Issue key is required.' };
     }
@@ -31,7 +31,7 @@ export function validateIssueKey(key) {
  * @param {string} key - The project key to validate.
  * @returns {{ valid: boolean, message?: string }}
  */
-export function validateProjectKey(key) {
+export function validateProjectKey(key: any): { valid: boolean; message?: string } {
     if (!key || typeof key !== 'string') {
         return { valid: false, message: 'Project key is required.' };
     }
@@ -54,7 +54,7 @@ export function validateProjectKey(key) {
  * @param {string} url - The URL to validate.
  * @returns {{ valid: boolean, message?: string }}
  */
-export function validateUrl(url) {
+export function validateUrl(url: any): { valid: boolean; message?: string } {
     if (!url || typeof url !== 'string') {
         return { valid: false, message: 'URL is required.' };
     }
@@ -78,7 +78,7 @@ export function validateUrl(url) {
  * @param {string} jql - The JQL query string.
  * @returns {string} The sanitized JQL string.
  */
-export function sanitizeJql(jql) {
+export function sanitizeJql(jql: any): string {
     if (!jql || typeof jql !== 'string') {
         return '';
     }