jira-pilot 2.0.4 → 2.1.0

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

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { startServer } from '../server/mcp-server.js';
 
-export function registerMcpCommand(program) {
+export function registerMcpCommand(program: Command) {
     const mcpCmd = new Command('mcp')
         .description('Start MCP Agent Server (Stdio)')
         .action(async () => {
@@ -17,7 +17,7 @@ export function registerMcpCommand(program) {
 
             try {
                 await startServer();
-            } catch (e) {
+            } catch (e: any) {
                 console.error('MCP Server Error:', e);
                 process.exit(1);
             }

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

@@ -1,11 +1,11 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { table } from 'table';
+import Table from 'cli-table3';
 import { api } from '../services/api-service.js';
 import ora from 'ora';
 import { handleCommandError } from '../utils/error-handler.js';
 
-export function registerProjectCommand(program) {
+export function registerProjectCommand(program: Command) {
     const projectCmd = new Command('project')
         .description('Manage Jira projects')
         .addHelpText('after', `
@@ -17,7 +17,7 @@ Common Actions:
         .command('list')
         .description('List accessible projects')
         .option('-o, --output <format>', 'Output format (json)')
-        .action(async (options) => {
+        .action(async (options: any) => {
             const spinner = ora('Fetching projects...').start();
             try {
                 const data = await api.get('/project/search');
@@ -29,19 +29,19 @@ Common Actions:
                 }
 
                 if (options.output === 'json') {
-                    console.log(JSON.stringify(data.values.map(p => ({
+                    console.log(JSON.stringify(data.values.map((p: any) => ({
                         key: p.key, name: p.name,
                         lead: p.lead?.displayName || null, style: p.style
                     })), null, 2));
                     return;
                 }
 
-                const tableData = [
-                    [chalk.bold('Key'), chalk.bold('Name'), chalk.bold('Leader'), chalk.bold('Style')]
-                ];
+                const table = new Table({
+                    head: [chalk.bold('Key'), chalk.bold('Name'), chalk.bold('Leader'), chalk.bold('Style')]
+                });
 
-                data.values.forEach(p => {
-                    tableData.push([
+                data.values.forEach((p: any) => {
+                    table.push([
                         chalk.cyan(p.key),
                         p.name,
                         p.lead ? p.lead.displayName : 'N/A',
@@ -49,8 +49,8 @@ Common Actions:
                     ]);
                 });
 
-                console.log(table(tableData));
-            } catch (e) {
+                console.log(table.toString());
+            } catch (e: any) {
                 handleCommandError(spinner, e, 'Failed to list projects');
             }
         });

package/src/commands/sprint.ts

@@ -0,0 +1,269 @@
+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';
+
+export function registerSprintCommand(program: Command) {
+    const sprintCmd = new Command('sprint')
+        .description('Manage Sprints')
+        .addHelpText('after', `
+Common Actions:
+  $ jira sprint list --board <ID|Name>   # List sprints for a board
+        `);
+
+    sprintCmd
+        .command('list')
+        .description('List sprints for a board')
+        .requiredOption('-b, --board <id>', 'Board ID or name')
+        .option('-s, --state <state>', 'State (active, future, closed)', 'active,future')
+        .action(async (options: any) => {
+            const spinner = ora(`Fetching sprints for board ${options.board}...`).start();
+            try {
+                let boardId = options.board;
+
+                // If board option is not a number, look it up by name
+                if (isNaN(boardId)) {
+                    spinner.text = `Looking up board "${options.board}"...`;
+                    const boardData = await api.agileGet(`/board?name=${encodeURIComponent(options.board)}`);
+
+                    if (!boardData.values || boardData.values.length === 0) {
+                        throw new Error(`Board with name "${options.board}" not found. Please provide the numeric Board ID.`);
+                    }
+
+                    if (boardData.values.length > 1) {
+                        const exact = boardData.values.find((b: any) => b.name.toLowerCase() === options.board.toLowerCase());
+                        if (exact) {
+                            boardId = exact.id;
+                        } else {
+                            console.log(chalk.yellow(`\nMultiple boards found for "${options.board}". Using "${boardData.values[0].name}" (ID: ${boardData.values[0].id}).`));
+                            boardId = boardData.values[0].id;
+                        }
+                    } else {
+                        boardId = boardData.values[0].id;
+                    }
+                    spinner.text = `Fetching sprints for board ${options.board} (ID: ${boardId})...`;
+                }
+
+                const data = await api.agileGet(`/board/${boardId}/sprint?state=${options.state}`);
+                spinner.stop();
+
+                if (!data.values || data.values.length === 0) {
+                    console.log(chalk.yellow('No sprints found.'));
+                    return;
+                }
+
+                const table = new Table({
+                    head: [chalk.bold('ID'), chalk.bold('Name'), chalk.bold('State'), chalk.bold('Dates')]
+                });
+
+                data.values.forEach((s: any) => {
+                    table.push([
+                        s.id,
+                        s.name,
+                        s.state === 'active' ? chalk.green(s.state) : s.state,
+                        `${s.startDate ? s.startDate.split('T')[0] : ''} -> ${s.endDate ? s.endDate.split('T')[0] : ''}`
+                    ]);
+                });
+
+                console.log(table.toString());
+
+            } catch (e: any) {
+                handleCommandError(spinner, e, 'Failed to list sprints');
+            }
+        });
+
+    // ── SPRINT ISSUES ────────────────────────────────────────────────
+    sprintCmd
+        .command('issues')
+        .description('List issues in the active sprint')
+        .requiredOption('-b, --board <id>', 'Board ID or name')
+        .option('-o, --output <format>', 'Output format (json)')
+        .addHelpText('after', `
+Examples:
+  $ jira sprint issues --board 5
+  $ jira sprint issues --board "My Board" --output json
+        `)
+        .action(async (options: any) => {
+            const spinner = ora('Fetching active sprint...').start();
+            try {
+                let boardId = options.board;
+
+                if (isNaN(boardId)) {
+                    spinner.text = `Looking up board "${options.board}"...`;
+                    const boardData = await api.agileGet(`/board?name=${encodeURIComponent(options.board)}`);
+                    if (!boardData.values || boardData.values.length === 0) {
+                        throw new Error(`Board "${options.board}" not found.`);
+                    }
+                    boardId = boardData.values[0].id;
+                }
+
+                // Get active sprint
+                const sprints = await api.agileGet(`/board/${boardId}/sprint?state=active`);
+                if (!sprints.values || sprints.values.length === 0) {
+                    spinner.stop();
+                    console.log(chalk.yellow('No active sprint found.'));
+                    return;
+                }
+
+                const activeSprint = sprints.values[0];
+                spinner.text = `Fetching issues for sprint "${activeSprint.name}"...`;
+
+                const issues = await api.agileGet(`/sprint/${activeSprint.id}/issue?maxResults=50&fields=summary,status,assignee,priority`);
+                spinner.stop();
+
+                if (!issues.issues || issues.issues.length === 0) {
+                    console.log(chalk.yellow('No issues in active sprint.'));
+                    return;
+                }
+
+                console.log(chalk.bold(`\n🏃 Sprint: ${activeSprint.name}\n`));
+
+                if (options.output === 'json') {
+                    console.log(JSON.stringify(issues.issues.map((i: any) => ({
+                        key: i.key, summary: i.fields.summary,
+                        status: i.fields.status?.name, assignee: i.fields.assignee?.displayName || null,
+                        priority: i.fields.priority?.name
+                    })), null, 2));
+                    return;
+                }
+
+                const table = new Table({
+                    head: [chalk.bold('Key'), chalk.bold('Summary'), chalk.bold('Status'), chalk.bold('Assignee'), chalk.bold('Priority')]
+                });
+                issues.issues.forEach((i: any) => {
+                    table.push([
+                        chalk.cyan(i.key),
+                        i.fields.summary ? (i.fields.summary.length > 50 ? i.fields.summary.substring(0, 47) + '...' : i.fields.summary) : '',
+                        i.fields.status?.name || '',
+                        i.fields.assignee?.displayName || 'Unassigned',
+                        i.fields.priority?.name || ''
+                    ]);
+                });
+                console.log(table.toString());
+                console.log(chalk.grey(`${issues.issues.length} issue(s) in sprint`));
+
+            } catch (e: any) {
+                handleCommandError(spinner, e, 'Failed to list sprint issues');
+            }
+        });
+
+
+
+    // ── START SPRINT ──────────────────────────────────────────────────
+    sprintCmd
+        .command('start')
+        .description('Start a future sprint')
+        .argument('<sprintId>', 'Sprint ID')
+        .option('--start-date <date>', 'Start date (YYYY-MM-DD)')
+        .option('--end-date <date>', 'End date (YYYY-MM-DD)')
+        .action(async (sprintId, options) => {
+            const spinner = ora(`Fetching sprint ${sprintId}...`).start();
+            try {
+                const sprint = await api.agileGet(`/sprint/${sprintId}`);
+
+                if (sprint.state === 'active') {
+                    spinner.fail(`Sprint "${sprint.name}" is already active.`);
+                    return;
+                }
+                if (sprint.state === 'closed') {
+                    spinner.fail(`Sprint "${sprint.name}" is closed.`);
+                    return;
+                }
+                spinner.stop();
+
+                let startDate = options.startDate;
+                let endDate = options.endDate;
+
+                if (!startDate || !endDate) {
+                    console.log(chalk.bold(`\nStarting Sprint: ${sprint.name}`));
+
+                    const now = new Date();
+                    const twoWeeks = new Date(now.getTime() + 14 * 24 * 60 * 60 * 1000);
+
+                    const answers = await enquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'startDate',
+                            message: 'Start Date (YYYY-MM-DD):',
+                            initial: now.toISOString().split('T')[0],
+                            skip: !!startDate
+                        },
+                        {
+                            type: 'input',
+                            name: 'endDate',
+                            message: 'End Date (YYYY-MM-DD):',
+                            initial: twoWeeks.toISOString().split('T')[0],
+                            skip: !!endDate
+                        }
+                    ]) as any;
+
+                    if (!startDate) startDate = answers.startDate;
+                    if (!endDate) endDate = answers.endDate;
+                }
+
+                // Append time to dates if missing (Jira requires ISO with time)
+                const formatISO = (dateStr: string) => {
+                    return dateStr.includes('T') ? dateStr : `${dateStr}T10:00:00.000+0000`;
+                };
+
+                const updateSpinner = ora('Starting sprint...').start();
+                await api.agilePost(`/sprint/${sprintId}`, {
+                    state: 'active',
+                    startDate: formatISO(startDate),
+                    endDate: formatISO(endDate)
+                });
+                updateSpinner.succeed(chalk.green(`Sprint "${chalk.bold(sprint.name)}" is now ACTIVE.`));
+
+            } catch (e: any) {
+                handleCommandError(spinner, e, 'Failed to start sprint');
+            }
+        });
+
+    // ── COMPLETE SPRINT ───────────────────────────────────────────────
+    sprintCmd
+        .command('complete')
+        .description('Complete (close) an active sprint')
+        .argument('<sprintId>', 'Sprint ID')
+        .action(async (sprintId) => {
+            const spinner = ora(`Fetching sprint ${sprintId}...`).start();
+            try {
+                const sprint = await api.agileGet(`/sprint/${sprintId}`);
+
+                if (sprint.state !== 'active') {
+                    spinner.fail(`Sprint "${sprint.name}" is not active (State: ${sprint.state}).`);
+                    return;
+                }
+                spinner.stop();
+
+                const { confirmed } = await enquirer.prompt({
+                    type: 'confirm',
+                    name: 'confirmed',
+                    message: `Are you sure you want to complete sprint "${chalk.cyan(sprint.name)}"?`,
+                    initial: false
+                }) as any;
+
+                if (!confirmed) return;
+
+                const closeSpinner = ora('Completing sprint...').start();
+                // Note: If there are incomplete issues, Jira API might error or require specific handling (swap).
+                // For simplified flow, we try basic close. If it fails, we inform user.
+                await api.agilePost(`/sprint/${sprintId}`, {
+                    state: 'closed'
+                });
+                closeSpinner.succeed(chalk.green(`Sprint "${chalk.bold(sprint.name)}" completed.`));
+
+            } catch (e: any) {
+                if (e.response && e.response.status === 400) {
+                    // Check if it mentions incomplete issues
+                    handleCommandError(spinner, e, 'Failed to complete sprint (Check if there are incomplete issues that need moving)');
+                } else {
+                    handleCommandError(spinner, e, 'Failed to complete sprint');
+                }
+            }
+        });
+
+    program.addCommand(sprintCmd);
+}

package/src/server/{mcp-server.js → mcp-server.ts}

@@ -60,6 +60,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["projectKey", "summary"]
                 }
             },
+            {
+                name: "jira_update_issue",
+                description: "Update an existing Jira issue. Supports updating summary, description, priority, and assignee.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        issueKey: { type: "string", description: "Issue Key (e.g., PROJ-123)" },
+                        summary: { type: "string", description: "New summary" },
+                        description: { type: "string", description: "New description (plain text)" },
+                        priority: { type: "string", description: "New priority name" },
+                        assigneeId: { type: "string", description: "New assignee account ID (or 'me', 'none')" }
+                    },
+                    required: ["issueKey"]
+                }
+            },
             {
                 name: "jira_transition_issue",
                 description: "Transition a Jira issue to a new status. First call with only issueKey to see available transitions, then call again with the transitionId.",
@@ -97,6 +112,27 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 }
             },
 
+            // ── Users ───────────────────────────────────────
+            {
+                name: "jira_search_users",
+                description: "Search for Jira users by name or email. Returns accountId and displayName.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Name, email, or part of it" }
+                    },
+                    required: ["query"]
+                }
+            },
+            {
+                name: "jira_myself",
+                description: "Get details about the current authenticated user.",
+                inputSchema: {
+                    type: "object",
+                    properties: {}
+                }
+            },
+
             // ── Projects & Sprints ──────────────────────────
             {
                 name: "jira_list_projects",
@@ -119,6 +155,46 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                     required: ["boardId"]
                 }
+            },
+            {
+                name: "jira_add_worklog",
+                description: "Log work to a Jira issue.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        issueKey: { type: "string", description: "Issue Key" },
+                        timeSpent: { type: "string", description: "Time spent (e.g., '2h 30m', '1d')" },
+                        comment: { type: "string", description: "Worklog comment" }
+                    },
+                    required: ["issueKey", "timeSpent"]
+                }
+            },
+            {
+                name: "jira_create_subtask",
+                description: "Create a subtask for a parent issue.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        parentKey: { type: "string", description: "Parent Issue Key" },
+                        summary: { type: "string", description: "Subtask summary" },
+                        description: { type: "string", description: "Subtask description" },
+                        priority: { type: "string", description: "Priority name" },
+                        assigneeId: { type: "string", description: "Assignee Account ID" }
+                    },
+                    required: ["parentKey", "summary"]
+                }
+            },
+            {
+                name: "jira_add_attachment",
+                description: "Attach a file to a Jira issue.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        issueKey: { type: "string", description: "Issue Key" },
+                        filePath: { type: "string", description: "Absolute path to the file to extract/upload" }
+                    },
+                    required: ["issueKey", "filePath"]
+                }
             }
         ]
     };
@@ -126,7 +202,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 
 // ── Tool Handlers ────────────────────────────────────────────────────
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
+    const { name, arguments: args } = request.params as { name: string; arguments: any };
 
     try {
         // ── jira_list_issues ────────────────────────────────
@@ -140,7 +216,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             });
 
             // Return a cleaner format for LLM consumption
-            const issues = (data.issues || []).map(i => ({
+            const issues = (data.issues || []).map((i: any) => ({
                 key: i.key,
                 summary: i.fields.summary,
                 status: i.fields.status?.name,
@@ -173,7 +249,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 updated: data.fields.updated,
                 description: data.fields.description,
                 labels: data.fields.labels,
-                comments: data.fields.comment?.comments?.map(c => ({
+                comments: data.fields.comment?.comments?.map((c: any) => ({
                     author: c.author.displayName,
                     body: c.body,
                     created: c.created
@@ -187,7 +263,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
         // ── jira_create_issue ───────────────────────────────
         if (name === "jira_create_issue") {
-            const body = {
+            const body: any = {
                 fields: {
                     project: { key: args.projectKey },
                     summary: args.summary,
@@ -225,7 +301,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     issueKey: args.issueKey,
                     summary: issue.fields.summary,
                     currentStatus: issue.fields.status?.name,
-                    availableTransitions: (transData.transitions || []).map(t => ({
+                    availableTransitions: (transData.transitions || []).map((t: any) => ({
                         id: t.id,
                         name: t.name,
                         toStatus: t.to.name
@@ -277,12 +353,77 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
 
+        // ── jira_update_issue ───────────────────────────────
+        if (name === "jira_update_issue") {
+            const updateBody: any = { fields: {} };
+
+            if (args.summary) updateBody.fields.summary = args.summary;
+            if (args.description) updateBody.fields.description = textToADF(args.description);
+            if (args.priority) updateBody.fields.priority = { name: args.priority };
+
+            if (args.assigneeId) {
+                let accId = args.assigneeId;
+                if (accId === 'me') {
+                    const myself = await api.get('/myself');
+                    accId = myself.accountId;
+                } else if (accId === 'none') {
+                    accId = null;
+                }
+                updateBody.fields.assignee = { accountId: accId };
+            }
+
+            if (Object.keys(updateBody.fields).length === 0) {
+                return {
+                    content: [{ type: "text", text: "No fields to update provided." }],
+                    isError: true
+                };
+            }
+
+            await api.put(`/issue/${args.issueKey}`, updateBody);
+
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, issueKey: args.issueKey }) }]
+            };
+        }
+
+        // ── jira_search_users ───────────────────────────────
+        if (name === "jira_search_users") {
+            const users = await api.get(`/user/search?query=${encodeURIComponent(args.query)}`);
+
+            const results = (users || []).map((u: any) => ({
+                accountId: u.accountId,
+                displayName: u.displayName,
+                email: u.emailAddress,
+                active: u.active
+            }));
+
+            return {
+                content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+            };
+        }
+
+        // ── jira_myself ─────────────────────────────────────
+        if (name === "jira_myself") {
+            const myself = await api.get('/myself');
+            const result = {
+                accountId: myself.accountId,
+                displayName: myself.displayName,
+                email: myself.emailAddress,
+                active: myself.active,
+                timeZone: myself.timeZone
+            };
+
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+            };
+        }
+
         // ── jira_list_projects ──────────────────────────────
         if (name === "jira_list_projects") {
             const limit = args.limit || 50;
             const data = await api.get(`/project/search?maxResults=${limit}`);
 
-            const projects = (data.values || []).map(p => ({
+            const projects = (data.values || []).map((p: any) => ({
                 key: p.key,
                 name: p.name,
                 lead: p.lead?.displayName || 'N/A',
@@ -300,7 +441,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const state = args.state || 'active,future';
             const data = await api.agileGet(`/board/${args.boardId}/sprint?state=${state}`);
 
-            const sprints = (data.values || []).map(s => ({
+            const sprints = (data.values || []).map((s: any) => ({
                 id: s.id,
                 name: s.name,
                 state: s.state,
@@ -314,9 +455,95 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
 
+        // ── jira_add_worklog ────────────────────────────────
+        if (name === "jira_add_worklog") {
+            const body: any = {
+                timeSpent: args.timeSpent
+            };
+            if (args.comment) {
+                body.comment = textToADF(args.comment);
+            }
+
+            await api.post(`/issue/${args.issueKey}/worklog`, body);
+
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, issueKey: args.issueKey, timeSpent: args.timeSpent }) }]
+            };
+        }
+
+        // ── jira_create_subtask ─────────────────────────────
+        if (name === "jira_create_subtask") {
+            // 1. Fetch parent to get project
+            const parent = await api.get(`/issue/${args.parentKey}?fields=project`);
+            const projectKey = parent.fields.project.key;
+
+            // 2. Find subtask issue type
+            const meta = await api.get(`/issue/createmeta/${projectKey}/issuetypes`);
+            const allTypes = meta.issueTypes || meta.values || [];
+            const subtaskTypes = allTypes.filter((t: any) => t.subtask);
+
+            if (subtaskTypes.length === 0) {
+                return {
+                    content: [{ type: "text", text: `Error: No subtask types found in project ${projectKey}` }],
+                    isError: true
+                };
+            }
+            const subtaskId = subtaskTypes[0].id; // Default to first available
+
+            const body: any = {
+                fields: {
+                    project: { key: projectKey },
+                    parent: { key: args.parentKey },
+                    issuetype: { id: subtaskId },
+                    summary: args.summary
+                }
+            };
+
+            if (args.description) body.fields.description = textToADF(args.description);
+            if (args.priority) body.fields.priority = { name: args.priority };
+            if (args.assigneeId) {
+                let accId = args.assigneeId;
+                if (accId === 'me') {
+                    const myself = await api.get('/myself');
+                    accId = myself.accountId;
+                }
+                body.fields.assignee = { accountId: accId };
+            }
+
+            const data = await api.post('/issue', body);
+            return {
+                content: [{ type: "text", text: JSON.stringify({ key: data.key, self: data.self }, null, 2) }]
+            };
+        }
+
+        // ── jira_add_attachment ─────────────────────────────
+        if (name === "jira_add_attachment") {
+            try {
+                // Dynamically import fs/path to avoid top-level node dependencies if this runs in browser-like env (unlikely but safe)
+                const { openAsBlob } = await import('node:fs');
+                const path = await import('node:path');
+
+                const filePath = args.filePath;
+                const file = await openAsBlob(filePath);
+                const formData = new FormData();
+                formData.append('file', file, path.default.basename(filePath));
+
+                const result = await api.upload(`/issue/${args.issueKey}/attachments`, formData);
+
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                };
+            } catch (e: any) {
+                return {
+                    content: [{ type: "text", text: `Error attaching file: ${e.message}` }],
+                    isError: true
+                };
+            }
+        }
+
         throw new Error(`Unknown tool: ${name}`);
 
-    } catch (e) {
+    } catch (e: any) {
         const errorMessage = e.response?.data ? JSON.stringify(e.response.data) : e.message;
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],