jira-pilot 2.0.4 → 2.1.0

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

@@ -2,10 +2,11 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import enquirer from 'enquirer';
 import { setCredentials, getCredentials, clearCredentials, saveProfile, loadProfile, deleteProfile, listProfiles, getActiveProfile } from '../utils/config.js';
+import ConfigStore from '../utils/config-store.js';
 import ora from 'ora';
 import { api } from '../services/api-service.js';
 
-export function registerConfigCommand(program) {
+export function registerConfigCommand(program: Command) {
     const configCmd = new Command('config')
         .description('Configure Jira credentials');
 
@@ -65,7 +66,7 @@ export function registerConfigCommand(program) {
                         initial: current.githubToken ? '*****' : undefined,
                         skip: function () { return !this.state.answers.aiEnabled; }
                     }
-                ]);
+                ] as any) as any;
 
                 // Keep existing token if user didn't change it (and entered ***** which is not real)
                 // Actually prompt returns text. If they leave it blank?
@@ -82,12 +83,12 @@ export function registerConfigCommand(program) {
                 try {
                     await api.get('/myself');
                     spinner.succeed(chalk.green('Credentials verified and saved!'));
-                } catch (e) {
+                } catch (e: any) {
                     spinner.fail(chalk.red('Verification failed! Credentials saved but might be incorrect.'));
                     console.error(e.message);
                 }
 
-            } catch (e) {
+            } catch (e: any) {
                 console.error(chalk.red('Setup cancelled or failed'), e);
             }
         });
@@ -130,7 +131,7 @@ export function registerConfigCommand(program) {
                     type: 'password',
                     name: 'aiKey',
                     message: 'Enter AI API Key:'
-                });
+                }) as any;
                 key = response.aiKey;
             }
 
@@ -162,7 +163,7 @@ export function registerConfigCommand(program) {
         .command('save')
         .description('Save current config as a named profile')
         .argument('<name>', 'Profile name')
-        .action((name) => {
+        .action((name: string) => {
             saveProfile(name);
             console.log(chalk.green(`Profile "${name}" saved and set as active.`));
         });
@@ -171,7 +172,7 @@ export function registerConfigCommand(program) {
         .command('use')
         .description('Switch to a saved profile')
         .argument('<name>', 'Profile name')
-        .action((name) => {
+        .action((name: string) => {
             if (loadProfile(name)) {
                 console.log(chalk.green(`Switched to profile "${name}".`));
                 const creds = getCredentials();
@@ -210,7 +211,7 @@ export function registerConfigCommand(program) {
         .command('delete-profile')
         .description('Delete a saved profile')
         .argument('<name>', 'Profile name')
-        .action((name) => {
+        .action((name: string) => {
             const profiles = listProfiles();
             if (!profiles.includes(name)) {
                 console.error(chalk.red(`Profile "${name}" not found.`));
@@ -220,5 +221,53 @@ export function registerConfigCommand(program) {
             console.log(chalk.green(`Profile "${name}" deleted.`));
         });
 
+    // ── CUSTOM FIELD MANAGEMENT ─────────────────────────────────────
+    const fieldCmd = new Command('field')
+        .description('Manage custom field aliases');
+
+    fieldCmd
+        .command('set')
+        .description('Set a custom field alias')
+        .argument('<alias>', 'Field Alias (e.g. storyPoints)')
+        .argument('<fieldId>', 'Field ID (e.g. customfield_10011)')
+        .action((alias, fieldId) => {
+            const config = new ConfigStore('jira-pilot');
+            config.set(`customFields.${alias}`, fieldId);
+            console.log(chalk.green(`Alias "${chalk.bold(alias)}" mapped to ${chalk.bold(fieldId)}.`));
+        });
+
+    fieldCmd
+        .command('list')
+        .description('List custom field aliases')
+        .action(() => {
+            const config = new ConfigStore('jira-pilot');
+            const fields = config.get('customFields') || {};
+            if (Object.keys(fields).length === 0) {
+                console.log(chalk.yellow('No custom field aliases defined.'));
+                return;
+            }
+            console.log(chalk.bold('\nCustom Field Aliases:\n'));
+            for (const [alias, id] of Object.entries(fields)) {
+                console.log(`  ${chalk.cyan(alias)}: ${id}`);
+            }
+            console.log('');
+        });
+
+    fieldCmd
+        .command('delete')
+        .description('Delete a custom field alias')
+        .argument('<alias>', 'Field Alias')
+        .action((alias) => {
+            const config = new ConfigStore('jira-pilot');
+            if (!config.get(`customFields.${alias}`)) {
+                console.error(chalk.red(`Alias "${alias}" not found.`));
+                return;
+            }
+            config.delete(`customFields.${alias}`);
+            console.log(chalk.green(`Alias "${chalk.bold(alias)}" deleted.`));
+        });
+
+    configCmd.addCommand(fieldCmd);
+
     program.addCommand(configCmd);
 }

package/src/commands/dashboard.ts

@@ -0,0 +1,222 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import ora from 'ora';
+import enquirer from 'enquirer';
+import { api } from '../services/api-service.js';
+import { handleCommandError } from '../utils/error-handler.js';
+
+// Utility for status icons
+const getStatusIcon = (status: string) => {
+    const s = status.toLowerCase();
+    if (s.includes('done') || s.includes('closed')) return '✅';
+    if (s.includes('progress')) return '🏃';
+    if (s.includes('review')) return '👀';
+    return '📝';
+};
+
+// Utility for priority icons/colors
+const getPriorityColor = (priority: string, text: string) => {
+    const p = priority.toLowerCase();
+    if (p.includes('highest')) return chalk.red.bold(text);
+    if (p.includes('high')) return chalk.red(text);
+    if (p.includes('medium')) return chalk.yellow(text);
+    if (p.includes('low')) return chalk.blue(text);
+    return chalk.grey(text);
+};
+
+export function registerDashboardCommand(program: Command) {
+    program
+        .command('dashboard')
+        .description('Interactive Jira Dashboard')
+        .option('-o, --output <format>', 'Output format (json)')
+        .action(async (options: any) => {
+            if (options.output === 'json') {
+                try {
+                    const [myIssues, recentIssues] = await Promise.all([
+                        api.post('/search/jql', {
+                            jql: 'assignee = currentUser() AND statusCategory != Done ORDER BY priority ASC, updated DESC',
+                            maxResults: 15,
+                            fields: ['summary', 'status', 'priority', 'updated']
+                        }),
+                        api.post('/search/jql', {
+                            jql: 'assignee = currentUser() ORDER BY updated DESC',
+                            maxResults: 5,
+                            fields: ['summary', 'status', 'updated']
+                        })
+                    ]);
+
+                    console.log(JSON.stringify({
+                        openIssues: (myIssues.issues || []).map((i: any) => ({
+                            key: i.key, summary: i.fields.summary,
+                            status: i.fields.status?.name, priority: i.fields.priority?.name
+                        })),
+                        recentActivity: (recentIssues.issues || []).map((i: any) => ({
+                            key: i.key, summary: i.fields.summary,
+                            status: i.fields.status?.name, updated: i.fields.updated
+                        }))
+                    }, null, 2));
+                } catch (e: any) {
+                    console.error(JSON.stringify({ error: e.message }));
+                }
+                return;
+            }
+
+            // ── Interactive Dashboard ────────────────────────────
+            while (true) {
+                console.clear();
+                const spinner = ora('Loading dashboard...').start();
+                try {
+                    const myself = await api.get('/myself');
+
+                    // Fetch in parallel: my open issues + recently updated
+                    const [myIssues, recentIssues] = await Promise.all([
+                        api.post('/search/jql', {
+                            jql: 'assignee = currentUser() AND statusCategory != Done ORDER BY priority ASC, updated DESC', // Fixed Sort
+                            maxResults: 15,
+                            fields: ['summary', 'status', 'priority', 'updated', 'issuetype']
+                        }),
+                        api.post('/search/jql', {
+                            jql: 'assignee = currentUser() ORDER BY updated DESC',
+                            maxResults: 5,
+                            fields: ['summary', 'status', 'updated']
+                        })
+                    ]);
+                    spinner.stop();
+
+                    // ── Header ───────────────────────────────────────────
+                    console.log(chalk.bold.blue('\n✈️  Jira Pilot Dashboard'));
+                    console.log(chalk.grey(`   User: ${myself.displayName} <${myself.emailAddress}>`));
+                    console.log('');
+
+                    // ── Open Issues Table ────────────────────────────────
+                    console.log(chalk.bold('📋 Your Open Issues') + chalk.grey(` (${myIssues.total || 0} total)`));
+
+                    const issues = myIssues.issues || [];
+
+                    if (issues.length > 0) {
+                        const table = new Table({
+                            head: [chalk.bold('Key'), chalk.bold('Type'), chalk.bold('Summary'), chalk.bold('Status'), chalk.bold('Priority')]
+                        });
+
+                        issues.forEach((i: any) => {
+                            table.push([
+                                chalk.cyan(i.key),
+                                i.fields.issuetype?.name || '',
+                                i.fields.summary ? (i.fields.summary.length > 40 ? i.fields.summary.substring(0, 37) + '...' : i.fields.summary) : '',
+                                i.fields.status?.name || '',
+                                getPriorityColor(i.fields.priority?.name || '', i.fields.priority?.name || '')
+                            ]);
+                        });
+                        console.log(table.toString());
+                    } else {
+                        console.log(chalk.green('  🎉 No open issues — nice work!'));
+                    }
+                    console.log('');
+
+                    // ── Interactive Menu ─────────────────────────────────
+                    // Enhancing the selection UI as requested
+                    const choices = [
+                        ...issues.map((i: any) => {
+                            const statusIcon = getStatusIcon(i.fields.status?.name || '');
+                            const priorityColor = getPriorityColor(i.fields.priority?.name || '', '●');
+                            const key = chalk.cyan.bold(i.key.padEnd(10));
+                            const summary = i.fields.summary.substring(0, 45);
+
+                            return {
+                                name: i.key,
+                                message: `${priorityColor} ${key} ${statusIcon}  ${summary}`,
+                                value: i.key
+                            };
+                        }),
+                        { role: 'separator' },
+                        { name: 'refresh', message: '🔄 Refresh Dashboard' },
+                        { name: 'exit', message: '🚪 Exit' }
+                    ];
+
+                    const { action } = await enquirer.prompt({
+                        type: 'select',
+                        name: 'action',
+                        message: 'Select an issue to manage:',
+                        choices: choices as any
+                    }) as any;
+
+                    if (action === 'exit') {
+                        console.log('Bye! 👋');
+                        process.exit(0);
+                    }
+
+                    if (action === 'refresh') {
+                        continue;
+                    }
+
+                    // Issue Selected: Show Action Menu
+                    const selectedKey = action;
+                    const { issueAction } = await enquirer.prompt({
+                        type: 'select',
+                        name: 'issueAction',
+                        message: `Action for ${chalk.cyan(selectedKey)}:`,
+                        choices: [
+                            { name: 'view', message: '📄 View Details' },
+                            { name: 'comment', message: '💬 Add Comment' },
+                            { name: 'transition', message: '🚀 Transition Status' },
+                            { name: 'assign', message: '👤 Assign' },
+                            { name: 'back', message: '⬅️  Back to Dashboard' }
+                        ]
+                    }) as any;
+
+                    if (issueAction === 'back') continue;
+
+                    if (issueAction === 'view') {
+                        const issue = await api.get(`/issue/${selectedKey}`);
+                        console.log(chalk.bold(`\n${issue.key}: ${issue.fields.summary}`));
+                        console.log(chalk.grey('────────────────────────────────────────'));
+                        console.log(`${getStatusIcon(issue.fields.status.name)} ${issue.fields.status.name}  |  ${getPriorityColor(issue.fields.priority?.name || '', issue.fields.priority?.name || '')}`);
+                        console.log(`\n${issue.fields.description || chalk.italic('No description')}\n`);
+                        await pause();
+                    }
+
+                    if (issueAction === 'comment') {
+                        const { inputComment } = await enquirer.prompt({
+                            type: 'input',
+                            name: 'inputComment',
+                            message: 'Comment:',
+                        }) as any;
+                        if (inputComment) {
+                            const { textToADF } = await import('../utils/text-to-adf.js');
+                            await api.post(`/issue/${selectedKey}/comment`, { body: textToADF(inputComment) });
+                            console.log(chalk.green('Comment added.'));
+                            await pause();
+                        }
+                    }
+
+                    if (issueAction === 'transition') {
+                        const transData = await api.get(`/issue/${selectedKey}/transitions`);
+                        const { transId } = await enquirer.prompt({
+                            type: 'select',
+                            name: 'transId',
+                            message: 'Select Status:',
+                            choices: transData.transitions.map((t: any) => ({ name: t.id, message: t.to.name }))
+                        }) as any;
+                        await api.post(`/issue/${selectedKey}/transitions`, { transition: { id: transId } });
+                        console.log(chalk.green('Transitioned.'));
+                        await pause();
+                    }
+
+                    if (issueAction === 'assign') {
+                        await api.put(`/issue/${selectedKey}/assignee`, { accountId: myself.accountId });
+                        console.log(chalk.green('Assigned to you.'));
+                        await pause();
+                    }
+
+                } catch (e: any) {
+                    handleCommandError(spinner, e, 'Dashboard Error');
+                    break;
+                }
+            }
+        });
+}
+
+async function pause() {
+    await enquirer.prompt({ type: 'input', name: 'cont', message: 'Press Enter to continue...' });
+}

package/src/commands/filter.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+import enquirer from 'enquirer';
+import { handleCommandError } from '../utils/error-handler.js';
+import { ConfigService } from '../services/config-service.js';
+
+export function registerFilterCommand(program: Command) {
+    const filterCmd = new Command('filter')
+        .description('Manage saved JQL filters (Local)')
+        .addHelpText('after', `
+Examples:
+  $ jira filter list
+  $ jira filter save "My Bugs" "assignee = currentUser() AND issuetype = Bug"
+  $ jira filter delete "My Bugs"
+        `);
+
+    filterCmd
+        .command('list')
+        .description('List saved filters')
+        .action(async () => {
+            const cfg = ConfigService.getConfig();
+            const filters = cfg.filters || {};
+
+            if (Object.keys(filters).length === 0) {
+                console.log(chalk.yellow('No local filters saved.'));
+                return;
+            }
+
+            const table = new Table({
+                head: [chalk.bold('Name'), chalk.bold('JQL')]
+            });
+
+            for (const [name, jql] of Object.entries(filters)) {
+                table.push([chalk.cyan(name), jql as string] as any);
+            }
+
+            console.log(table.toString());
+        });
+
+    filterCmd
+        .command('save')
+        .description('Save a JQL filter locally')
+        .argument('<name>', 'Filter Name')
+        .argument('<jql>', 'JQL Query')
+        .action(async (name, jql) => {
+            try {
+                const cfg = ConfigService.getConfig();
+                if (!cfg.filters) cfg.filters = {};
+
+                cfg.filters[name] = jql;
+                ConfigService.saveConfig(cfg);
+
+                console.log(chalk.green(`Filter "${chalk.bold(name)}" saved.`));
+            } catch (e: any) {
+                console.error(chalk.red(`Failed to save filter: ${e.message}`));
+            }
+        });
+
+    filterCmd
+        .command('delete')
+        .description('Delete a saved filter')
+        .argument('<name>', 'Filter Name')
+        .action(async (name) => {
+            try {
+                const cfg = ConfigService.getConfig();
+                if (!cfg.filters || !cfg.filters[name]) {
+                    console.log(chalk.yellow(`Filter "${name}" not found.`));
+                    return;
+                }
+
+                delete cfg.filters[name];
+                ConfigService.saveConfig(cfg);
+
+                console.log(chalk.green(`Filter "${chalk.bold(name)}" deleted.`));
+            } catch (e: any) {
+                console.error(chalk.red(`Failed to delete filter: ${e.message}`));
+            }
+        });
+
+    program.addCommand(filterCmd);
+}

package/src/commands/{git.js → git.ts}

@@ -7,7 +7,7 @@ import enquirer from 'enquirer';
 import { validateIssueKey } from '../utils/validators.js';
 import { handleCommandError } from '../utils/error-handler.js';
 
-export function registerGitCommand(program) {
+export function registerGitCommand(program: Command) {
     const gitCmd = new Command('git')
         .description('Git integration for Jira');
 
@@ -16,7 +16,7 @@ export function registerGitCommand(program) {
         .description('Create a git branch from a Jira issue')
         .argument('<issueKey>', 'Jira Issue Key (e.g., PROJ-123)')
         .option('-t, --type <type>', 'Branch type (feature, bugfix, hotfix)', 'feature')
-        .action(async (issueKey, options) => {
+        .action(async (issueKey: string, options: any) => {
             const check = validateIssueKey(issueKey);
             if (!check.valid) { console.error(chalk.red(check.message)); return; }
             const spinner = ora(`Fetching issue ${issueKey}...`).start();
@@ -39,7 +39,7 @@ export function registerGitCommand(program) {
                     name: 'confirm',
                     message: 'Create and switch to this branch?',
                     initial: true
-                });
+                }) as any;
 
                 if (confirm) {
                     try {
@@ -50,7 +50,7 @@ export function registerGitCommand(program) {
                     }
                 }
 
-            } catch (e) {
+            } catch (e: any) {
                 handleCommandError(spinner, e, 'Failed to create branch');
             }
         });

package/src/commands/issue-attach.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { validateIssueKey } from '../utils/validators.js';
+import { handleCommandError } from '../utils/error-handler.js';
+// Node 20+ has global FormData and File, but for type safety or older environments:
+// We rely on global FormData.
+
+export function registerAttachCommand(issueCmd: Command) {
+    issueCmd
+        .command('attach')
+        .description('Attach a file to an issue')
+        .argument('<issueKey>', 'Issue Key')
+        .argument('<filePath>', 'Path to file')
+        .action(async (issueKey, filePath) => {
+            const check = validateIssueKey(issueKey);
+            if (!check.valid) { console.error(chalk.red(check.message)); return; }
+
+            if (!fs.existsSync(filePath)) {
+                console.error(chalk.red(`File not found: ${filePath}`));
+                return;
+            }
+
+            const spinner = ora(`Uploading ${path.basename(filePath)} to ${issueKey}...`).start();
+            try {
+                // Use fs.openAsBlob (Node 20+)
+                // @ts-ignore - TS might not know openAsBlob if target is old, but engine is Node 20
+                const blob = await fs.openAsBlob(filePath);
+
+                const formData = new FormData();
+                formData.append('file', blob, path.basename(filePath));
+
+                await api.upload(`/issue/${issueKey}/attachments`, formData);
+
+                spinner.succeed(chalk.green(`Attached ${chalk.bold(path.basename(filePath))} to ${issueKey}`));
+
+            } catch (e: any) {
+                handleCommandError(spinner, e, 'Failed to attach file');
+            }
+        });
+}

package/src/commands/issue-pr.ts

@@ -0,0 +1,87 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import enquirer from 'enquirer';
+import { api } from '../services/api-service.js';
+import ora from 'ora';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { validateIssueKey } from '../utils/validators.js';
+import { handleCommandError } from '../utils/error-handler.js';
+import { parseADF } from '../utils/adf-parser.js';
+
+const execAsync = promisify(exec);
+
+export function registerPrCommand(issueCmd: Command) {
+    issueCmd
+        .command('pr')
+        .description('Create a GitHub Pull Request for an issue')
+        .argument('<issueKey>', 'Issue Key')
+        .action(async (issueKey) => {
+            const check = validateIssueKey(issueKey);
+            if (!check.valid) { console.error(chalk.red(check.message)); return; }
+
+            const spinner = ora(`Fetching issue ${issueKey}...`).start();
+            try {
+                // Check if gh CLI is installed
+                try {
+                    await execAsync('gh --version');
+                } catch (e) {
+                    spinner.fail('GitHub CLI (`gh`) is not installed or not in PATH.');
+                    console.log(chalk.yellow('Please install GitHub CLI to use this feature: https://cli.github.com/'));
+                    return;
+                }
+
+                const issue = await api.get(`/issue/${issueKey}?fields=summary,description,issuetype`);
+                spinner.stop();
+
+                const summary = issue.fields.summary;
+                const description = parseADF(issue.fields.description) || '';
+                const type = issue.fields.issuetype.name.toUpperCase();
+
+                // Construct PR Title and Body
+                const prTitle = `${issueKey}: ${summary}`;
+                const prBody = `## Related Issue\n\n[${issueKey}](${api.domain}/browse/${issueKey})\n\n## Description\n\n${description}\n\n## Type of Change\n\n- [ ] ${type}`;
+
+                console.log(chalk.bold('\nDraft PR Content:'));
+                console.log(chalk.cyan('Title: ') + prTitle);
+                console.log(chalk.cyan('Body:  ') + prBody.substring(0, 100) + '...\n');
+
+                const { confirm } = await enquirer.prompt({
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Create Pull Request with `gh`?',
+                    initial: true
+                }) as any;
+
+                if (!confirm) {
+                    console.log(chalk.yellow('Cancelled.'));
+                    return;
+                }
+
+                const prSpinner = ora('Running gh pr create...').start();
+
+                // Escape characters for shell is tricky, so we use --title and --body flags carefully.
+                // A better approach for robust CLI usage might be to spawn the process with args directly to avoid shell parsing issues.
+                // However, execAsync with proper escaping or spawn is needed. For simplicity in this demo, we can use a basic approach
+                // or write to a temp file. To be safe, let's just pass them as arguments but be mindful of quotes.
+                // For Windows compatibility, this can be complex.
+                // Alternative: Interactive mode of gh pr create?
+                // `gh pr create --title "..." --body "..."`
+
+                // We will try running interactive mode if we can't easily pass args, but interactive inside a child_process is hard.
+                // Let's try passing args.
+
+                // Sanitize title and body for shell execution (basic)
+                const safeTitle = prTitle.replace(/"/g, '\\"');
+                const safeBody = prBody.replace(/"/g, '\\"');
+
+                const command = `gh pr create --title "${safeTitle}" --body "${safeBody}" --web`;
+
+                await execAsync(command);
+                prSpinner.succeed('Pull Request created! (Browser opened)');
+
+            } catch (e: any) {
+                handleCommandError(spinner, e, 'Failed to create PR');
+            }
+        });
+}