jira-ai 0.1.0

package/dist/commands/project-statuses.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectStatusesCommand = projectStatusesCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const jira_client_1 = require("../lib/jira-client");
+const formatters_1 = require("../lib/formatters");
+async function projectStatusesCommand(projectId) {
+    const spinner = (0, ora_1.default)(`Fetching statuses for project ${projectId}...`).start();
+    try {
+        const statuses = await (0, jira_client_1.getProjectStatuses)(projectId);
+        spinner.succeed(chalk_1.default.green('Project statuses retrieved'));
+        console.log((0, formatters_1.formatProjectStatuses)(projectId, statuses));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to fetch project statuses'));
+        console.error(chalk_1.default.red('\nError: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        process.exit(1);
+    }
+}

package/dist/commands/projects.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectsCommand = projectsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const jira_client_1 = require("../lib/jira-client");
+const formatters_1 = require("../lib/formatters");
+const settings_1 = require("../lib/settings");
+async function projectsCommand() {
+    const spinner = (0, ora_1.default)('Fetching projects...').start();
+    try {
+        const allProjects = await (0, jira_client_1.getProjects)();
+        const allowedProjectKeys = (0, settings_1.getAllowedProjects)();
+        // Filter projects based on settings
+        const filteredProjects = allowedProjectKeys.includes('all')
+            ? allProjects
+            : allProjects.filter(project => (0, settings_1.isProjectAllowed)(project.key));
+        spinner.succeed(chalk_1.default.green('Projects retrieved'));
+        if (filteredProjects.length === 0) {
+            console.log(chalk_1.default.yellow('\nNo projects match your settings configuration.'));
+            console.log(chalk_1.default.gray('Allowed projects: ' + allowedProjectKeys.join(', ')));
+        }
+        else {
+            console.log((0, formatters_1.formatProjects)(filteredProjects));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to fetch projects'));
+        console.error(chalk_1.default.red('\nError: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        process.exit(1);
+    }
+}

package/dist/commands/run-jql.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJqlCommand = runJqlCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const jira_client_1 = require("../lib/jira-client");
+const formatters_1 = require("../lib/formatters");
+async function runJqlCommand(jqlQuery, options) {
+    // Validate JQL query is not empty
+    if (!jqlQuery || jqlQuery.trim() === '') {
+        console.error(chalk_1.default.red('\nError: JQL query cannot be empty'));
+        process.exit(1);
+    }
+    // Parse and validate limit parameter
+    let maxResults = 50; // default
+    if (options.limit) {
+        const parsedLimit = parseInt(options.limit, 10);
+        if (isNaN(parsedLimit) || parsedLimit < 1) {
+            console.error(chalk_1.default.red('\nError: Limit must be a positive number'));
+            process.exit(1);
+        }
+        if (parsedLimit > 1000) {
+            console.warn(chalk_1.default.yellow('\nWarning: Limit is very high. Using 1000 as maximum.'));
+            maxResults = 1000;
+        }
+        else {
+            maxResults = parsedLimit;
+        }
+    }
+    const spinner = (0, ora_1.default)('Executing JQL query...').start();
+    try {
+        const issues = await (0, jira_client_1.searchIssuesByJql)(jqlQuery, maxResults);
+        spinner.succeed(chalk_1.default.green('Query executed successfully'));
+        console.log((0, formatters_1.formatJqlResults)(issues));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to execute JQL query'));
+        console.error(chalk_1.default.red('\nError: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        process.exit(1);
+    }
+}

package/dist/commands/task-with-details.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskWithDetailsCommand = taskWithDetailsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const jira_client_1 = require("../lib/jira-client");
+const formatters_1 = require("../lib/formatters");
+async function taskWithDetailsCommand(taskId) {
+    const spinner = (0, ora_1.default)(`Fetching details for ${taskId}...`).start();
+    try {
+        const task = await (0, jira_client_1.getTaskWithDetails)(taskId);
+        spinner.succeed(chalk_1.default.green('Task details retrieved'));
+        console.log((0, formatters_1.formatTaskDetails)(task));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to fetch task details'));
+        console.error(chalk_1.default.red('\nError: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        process.exit(1);
+    }
+}

package/dist/commands/update-description.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDescriptionCommand = updateDescriptionCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const md_to_adf_1 = __importDefault(require("md-to-adf"));
+const jira_client_1 = require("../lib/jira-client");
+async function updateDescriptionCommand(taskId, options) {
+    // Validate taskId
+    if (!taskId || taskId.trim() === '') {
+        console.error(chalk_1.default.red('\nError: Task ID cannot be empty'));
+        process.exit(1);
+    }
+    // Validate file path
+    const filePath = options.fromFile;
+    if (!filePath || filePath.trim() === '') {
+        console.error(chalk_1.default.red('\nError: File path is required (use --from-file)'));
+        process.exit(1);
+    }
+    // Resolve file path to absolute
+    const absolutePath = path.resolve(filePath);
+    // Check file exists
+    if (!fs.existsSync(absolutePath)) {
+        console.error(chalk_1.default.red(`\nError: File not found: ${absolutePath}`));
+        process.exit(1);
+    }
+    // Read file
+    let markdownContent;
+    try {
+        markdownContent = fs.readFileSync(absolutePath, 'utf-8');
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError reading file: ' +
+            (error instanceof Error ? error.message : 'Unknown error')));
+        process.exit(1);
+    }
+    // Validate file is not empty
+    if (markdownContent.trim() === '') {
+        console.error(chalk_1.default.red('\nError: File is empty'));
+        process.exit(1);
+    }
+    // Convert Markdown to ADF
+    let adfContent;
+    try {
+        adfContent = (0, md_to_adf_1.default)(markdownContent);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\nError converting Markdown to ADF: ' +
+            (error instanceof Error ? error.message : 'Unknown error')));
+        process.exit(1);
+    }
+    // Update issue description with spinner
+    const spinner = (0, ora_1.default)(`Updating description for ${taskId}...`).start();
+    try {
+        await (0, jira_client_1.updateIssueDescription)(taskId, adfContent);
+        spinner.succeed(chalk_1.default.green(`Description updated successfully for ${taskId}`));
+        console.log(chalk_1.default.gray(`\nFile: ${absolutePath}`));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to update description'));
+        console.error(chalk_1.default.red('\nError: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        // Provide helpful hints based on error
+        if (error instanceof Error && error.message.includes('404')) {
+            console.log(chalk_1.default.yellow('\nHint: Check that the task ID is correct'));
+        }
+        else if (error instanceof Error && error.message.includes('403')) {
+            console.log(chalk_1.default.yellow('\nHint: You may not have permission to edit this issue'));
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/formatters.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUserInfo = formatUserInfo;
+exports.formatProjects = formatProjects;
+exports.formatTaskDetails = formatTaskDetails;
+exports.formatProjectStatuses = formatProjectStatuses;
+exports.formatJqlResults = formatJqlResults;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const utils_1 = require("./utils");
+/**
+ * Create a styled table
+ */
+function createTable(headers, colWidths) {
+    return new cli_table3_1.default({
+        head: headers.map((h) => chalk_1.default.cyan.bold(h)),
+        style: {
+            head: [],
+            border: ['gray'],
+        },
+        colWidths,
+        wordWrap: true,
+    });
+}
+/**
+ * Format user info
+ */
+function formatUserInfo(user) {
+    const table = createTable(['Property', 'Value'], [20, 50]);
+    table.push(['Host', process.env.JIRA_HOST || 'N/A'], ['Display Name', user.displayName], ['Email', user.emailAddress], ['Account ID', user.accountId], ['Status', user.active ? chalk_1.default.green('Active') : chalk_1.default.red('Inactive')], ['Time Zone', user.timeZone]);
+    return '\n' + chalk_1.default.bold('User Information:') + '\n' + table.toString() + '\n';
+}
+/**
+ * Format projects list
+ */
+function formatProjects(projects) {
+    if (projects.length === 0) {
+        return chalk_1.default.yellow('No projects found.');
+    }
+    const table = createTable(['Key', 'Name', 'Type', 'Lead'], [12, 35, 15, 25]);
+    projects.forEach((project) => {
+        table.push([
+            chalk_1.default.cyan(project.key),
+            (0, utils_1.truncate)(project.name, 35),
+            project.projectTypeKey,
+            project.lead?.displayName || chalk_1.default.gray('N/A'),
+        ]);
+    });
+    let output = '\n' + chalk_1.default.bold(`Projects (${projects.length} total)`) + '\n\n';
+    output += table.toString() + '\n';
+    return output;
+}
+/**
+ * Format task details with comments
+ */
+function formatTaskDetails(task) {
+    let output = '\n' + chalk_1.default.bold.cyan(`${task.key}: ${task.summary}`) + '\n\n';
+    // Basic info table
+    const infoTable = createTable(['Property', 'Value'], [15, 65]);
+    infoTable.push(['Status', chalk_1.default.green(task.status.name)], ['Assignee', task.assignee?.displayName || chalk_1.default.gray('Unassigned')], ['Reporter', task.reporter?.displayName || chalk_1.default.gray('N/A')], ['Created', (0, utils_1.formatTimestamp)(task.created)], ['Updated', (0, utils_1.formatTimestamp)(task.updated)]);
+    output += infoTable.toString() + '\n\n';
+    // Parent Task
+    if (task.parent) {
+        output += chalk_1.default.bold('Parent Task:') + '\n';
+        const parentTable = createTable(['Key', 'Summary', 'Status'], [12, 50, 18]);
+        parentTable.push([
+            chalk_1.default.cyan(task.parent.key),
+            (0, utils_1.truncate)(task.parent.summary, 50),
+            task.parent.status.name,
+        ]);
+        output += parentTable.toString() + '\n\n';
+    }
+    // Subtasks
+    if (task.subtasks && task.subtasks.length > 0) {
+        output += chalk_1.default.bold(`Subtasks (${task.subtasks.length}):`) + '\n';
+        const subtasksTable = createTable(['Key', 'Summary', 'Status'], [12, 50, 18]);
+        task.subtasks.forEach((subtask) => {
+            subtasksTable.push([
+                chalk_1.default.cyan(subtask.key),
+                (0, utils_1.truncate)(subtask.summary, 50),
+                subtask.status.name,
+            ]);
+        });
+        output += subtasksTable.toString() + '\n\n';
+    }
+    // Description
+    if (task.description) {
+        output += chalk_1.default.bold('Description:') + '\n';
+        output += chalk_1.default.dim('─'.repeat(80)) + '\n';
+        output += task.description + '\n';
+        output += chalk_1.default.dim('─'.repeat(80)) + '\n\n';
+    }
+    // Comments
+    if (task.comments.length > 0) {
+        output += chalk_1.default.bold(`Comments (${task.comments.length}):`) + '\n\n';
+        task.comments.forEach((comment, index) => {
+            output += chalk_1.default.cyan(`${index + 1}. ${comment.author.displayName}`) +
+                chalk_1.default.gray(` - ${(0, utils_1.formatTimestamp)(comment.created)}`) + '\n';
+            output += chalk_1.default.dim('─'.repeat(80)) + '\n';
+            output += comment.body + '\n';
+            output += chalk_1.default.dim('─'.repeat(80)) + '\n\n';
+        });
+    }
+    else {
+        output += chalk_1.default.gray('No comments yet.\n\n');
+    }
+    return output;
+}
+/**
+ * Format project statuses list
+ */
+function formatProjectStatuses(projectKey, statuses) {
+    if (statuses.length === 0) {
+        return chalk_1.default.yellow('No statuses found for this project.');
+    }
+    const table = createTable(['Status Name', 'Category', 'Description'], [25, 20, 45]);
+    // Sort statuses by category for better readability
+    const sortedStatuses = [...statuses].sort((a, b) => {
+        const categoryOrder = ['TODO', 'IN_PROGRESS', 'DONE'];
+        const aIndex = categoryOrder.indexOf(a.statusCategory.key.toUpperCase());
+        const bIndex = categoryOrder.indexOf(b.statusCategory.key.toUpperCase());
+        return aIndex - bIndex;
+    });
+    sortedStatuses.forEach((status) => {
+        // Color code based on status category
+        let categoryColor = chalk_1.default.white;
+        if (status.statusCategory.key.toLowerCase() === 'done') {
+            categoryColor = chalk_1.default.green;
+        }
+        else if (status.statusCategory.key.toLowerCase() === 'indeterminate') {
+            categoryColor = chalk_1.default.yellow;
+        }
+        else if (status.statusCategory.key.toLowerCase() === 'new') {
+            categoryColor = chalk_1.default.blue;
+        }
+        table.push([
+            chalk_1.default.cyan(status.name),
+            categoryColor(status.statusCategory.name),
+            (0, utils_1.truncate)(status.description || chalk_1.default.gray('No description'), 45),
+        ]);
+    });
+    let output = '\n' + chalk_1.default.bold(`Project ${projectKey} - Available Statuses (${statuses.length} total)`) + '\n\n';
+    output += table.toString() + '\n';
+    return output;
+}
+/**
+ * Format JQL query results
+ */
+function formatJqlResults(issues) {
+    if (issues.length === 0) {
+        return chalk_1.default.yellow('\nNo issues found matching your JQL query.\n');
+    }
+    const table = createTable(['Key', 'Summary', 'Status', 'Assignee', 'Priority'], [12, 40, 18, 20, 12]);
+    issues.forEach((issue) => {
+        // Color-code status
+        let statusColor = chalk_1.default.white;
+        const statusLower = issue.status.name.toLowerCase();
+        if (statusLower.includes('done') || statusLower.includes('closed') || statusLower.includes('resolved')) {
+            statusColor = chalk_1.default.green;
+        }
+        else if (statusLower.includes('progress') || statusLower.includes('review')) {
+            statusColor = chalk_1.default.yellow;
+        }
+        // Color-code priority
+        let priorityColor = chalk_1.default.white;
+        const priorityName = issue.priority?.name || chalk_1.default.gray('None');
+        if (issue.priority) {
+            const priorityLower = issue.priority.name.toLowerCase();
+            if (priorityLower.includes('highest') || priorityLower.includes('high')) {
+                priorityColor = chalk_1.default.red;
+            }
+            else if (priorityLower.includes('medium')) {
+                priorityColor = chalk_1.default.yellow;
+            }
+            else if (priorityLower.includes('low')) {
+                priorityColor = chalk_1.default.blue;
+            }
+        }
+        table.push([
+            chalk_1.default.cyan(issue.key),
+            (0, utils_1.truncate)(issue.summary, 40),
+            statusColor(issue.status.name),
+            issue.assignee ? (0, utils_1.truncate)(issue.assignee.displayName, 20) : chalk_1.default.gray('Unassigned'),
+            typeof priorityName === 'string' ? priorityColor(priorityName) : priorityName,
+        ]);
+    });
+    let output = '\n' + chalk_1.default.bold(`Results (${issues.length} total)`) + '\n\n';
+    output += table.toString() + '\n';
+    return output;
+}

package/dist/lib/jira-client.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJiraClient = getJiraClient;
+exports.getCurrentUser = getCurrentUser;
+exports.getProjects = getProjects;
+exports.getTaskWithDetails = getTaskWithDetails;
+exports.getProjectStatuses = getProjectStatuses;
+exports.searchIssuesByJql = searchIssuesByJql;
+exports.updateIssueDescription = updateIssueDescription;
+exports.addIssueComment = addIssueComment;
+const jira_js_1 = require("jira.js");
+const utils_1 = require("./utils");
+let jiraClient = null;
+/**
+ * Get or create Jira client instance
+ */
+function getJiraClient() {
+    if (!jiraClient) {
+        jiraClient = new jira_js_1.Version3Client({
+            host: process.env.JIRA_HOST,
+            authentication: {
+                basic: {
+                    email: process.env.JIRA_USER_EMAIL,
+                    apiToken: process.env.JIRA_API_TOKEN,
+                },
+            },
+        });
+    }
+    return jiraClient;
+}
+/**
+ * Get current user information
+ */
+async function getCurrentUser() {
+    const client = getJiraClient();
+    const user = await client.myself.getCurrentUser();
+    return {
+        accountId: user.accountId || '',
+        displayName: user.displayName || '',
+        emailAddress: user.emailAddress || '',
+        active: user.active || false,
+        timeZone: user.timeZone || '',
+    };
+}
+/**
+ * Get all projects
+ */
+async function getProjects() {
+    const client = getJiraClient();
+    const response = await client.projects.searchProjects({
+        expand: 'lead',
+    });
+    return response.values.map((project) => ({
+        id: project.id,
+        key: project.key,
+        name: project.name,
+        projectTypeKey: project.projectTypeKey,
+        lead: project.lead ? {
+            displayName: project.lead.displayName,
+        } : undefined,
+    }));
+}
+/**
+ * Get task details with comments
+ */
+async function getTaskWithDetails(taskId) {
+    const client = getJiraClient();
+    // Get issue details
+    const issue = await client.issues.getIssue({
+        issueIdOrKey: taskId,
+        fields: [
+            'summary',
+            'description',
+            'status',
+            'assignee',
+            'reporter',
+            'created',
+            'updated',
+            'comment',
+            'parent',
+            'subtasks',
+        ],
+    });
+    // Extract comments
+    const comments = issue.fields.comment?.comments?.map((comment) => ({
+        id: comment.id,
+        author: {
+            displayName: comment.author?.displayName || 'Unknown',
+            emailAddress: comment.author?.emailAddress,
+        },
+        body: (0, utils_1.convertADFToMarkdown)(comment.body),
+        created: comment.created || '',
+        updated: comment.updated || '',
+    })) || [];
+    // Convert description from ADF to Markdown
+    const descriptionMarkdown = (0, utils_1.convertADFToMarkdown)(issue.fields.description);
+    const description = descriptionMarkdown || undefined;
+    // Extract parent if exists
+    const parent = issue.fields.parent ? {
+        id: issue.fields.parent.id,
+        key: issue.fields.parent.key,
+        summary: issue.fields.parent.fields?.summary || '',
+        status: {
+            name: issue.fields.parent.fields?.status?.name || 'Unknown',
+        },
+    } : undefined;
+    // Extract subtasks
+    const subtasks = issue.fields.subtasks?.map((subtask) => ({
+        id: subtask.id,
+        key: subtask.key,
+        summary: subtask.fields?.summary || '',
+        status: {
+            name: subtask.fields?.status?.name || 'Unknown',
+        },
+    })) || [];
+    return {
+        id: issue.id || '',
+        key: issue.key || '',
+        summary: issue.fields.summary || '',
+        description,
+        status: {
+            name: issue.fields.status?.name || 'Unknown',
+        },
+        assignee: issue.fields.assignee ? {
+            displayName: issue.fields.assignee.displayName || 'Unknown',
+        } : undefined,
+        reporter: issue.fields.reporter ? {
+            displayName: issue.fields.reporter.displayName || 'Unknown',
+        } : undefined,
+        created: issue.fields.created || '',
+        updated: issue.fields.updated || '',
+        comments,
+        parent,
+        subtasks,
+    };
+}
+/**
+ * Get all possible statuses for a project
+ */
+async function getProjectStatuses(projectIdOrKey) {
+    const client = getJiraClient();
+    // Get all statuses for the project
+    const statuses = await client.projects.getAllStatuses({
+        projectIdOrKey,
+    });
+    // Flatten and deduplicate statuses from all issue types
+    const statusMap = new Map();
+    statuses.forEach((issueTypeStatuses) => {
+        issueTypeStatuses.statuses?.forEach((status) => {
+            if (!statusMap.has(status.id)) {
+                statusMap.set(status.id, {
+                    id: status.id || '',
+                    name: status.name || '',
+                    description: status.description,
+                    statusCategory: {
+                        id: status.statusCategory?.id || '',
+                        key: status.statusCategory?.key || '',
+                        name: status.statusCategory?.name || '',
+                    },
+                });
+            }
+        });
+    });
+    return Array.from(statusMap.values());
+}
+/**
+ * Search for issues using JQL query
+ */
+async function searchIssuesByJql(jqlQuery, maxResults) {
+    const client = getJiraClient();
+    const response = await client.issueSearch.searchForIssuesUsingJqlEnhancedSearch({
+        jql: jqlQuery,
+        maxResults,
+        fields: ['summary', 'status', 'assignee', 'priority'],
+    });
+    return response.issues?.map((issue) => ({
+        key: issue.key || '',
+        summary: issue.fields?.summary || '',
+        status: {
+            name: issue.fields?.status?.name || 'Unknown',
+        },
+        assignee: issue.fields?.assignee ? {
+            displayName: issue.fields.assignee.displayName || 'Unknown',
+        } : null,
+        priority: issue.fields?.priority ? {
+            name: issue.fields.priority.name || 'Unknown',
+        } : null,
+    })) || [];
+}
+/**
+ * Update the description of a Jira issue
+ * @param taskId - The issue key (e.g., "PROJ-123")
+ * @param adfContent - The description content in ADF format
+ */
+async function updateIssueDescription(taskId, adfContent) {
+    const client = getJiraClient();
+    await client.issues.editIssue({
+        issueIdOrKey: taskId,
+        fields: {
+            description: adfContent,
+        },
+        notifyUsers: false,
+    });
+}
+/**
+ * Add a comment to a Jira issue
+ * @param taskId - The issue key (e.g., "PROJ-123")
+ * @param adfContent - The comment content in ADF format
+ */
+async function addIssueComment(taskId, adfContent) {
+    const client = getJiraClient();
+    await client.issueComments.addComment({
+        issueIdOrKey: taskId,
+        comment: adfContent,
+    });
+}