jira-ai 0.1.0

package/src/commands/update-description.ts

@@ -0,0 +1,94 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import * as fs from 'fs';
+import * as path from 'path';
+import mdToAdf from 'md-to-adf';
+import { updateIssueDescription } from '../lib/jira-client';
+
+export async function updateDescriptionCommand(
+  taskId: string,
+  options: { fromFile: string }
+): Promise<void> {
+  // Validate taskId
+  if (!taskId || taskId.trim() === '') {
+    console.error(chalk.red('\nError: Task ID cannot be empty'));
+    process.exit(1);
+  }
+
+  // Validate file path
+  const filePath = options.fromFile;
+  if (!filePath || filePath.trim() === '') {
+    console.error(chalk.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.red(`\nError: File not found: ${absolutePath}`));
+    process.exit(1);
+  }
+
+  // Read file
+  let markdownContent: string;
+  try {
+    markdownContent = fs.readFileSync(absolutePath, 'utf-8');
+  } catch (error) {
+    console.error(
+      chalk.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.red('\nError: File is empty'));
+    process.exit(1);
+  }
+
+  // Convert Markdown to ADF
+  let adfContent: any;
+  try {
+    adfContent = mdToAdf(markdownContent);
+  } catch (error) {
+    console.error(
+      chalk.red(
+        '\nError converting Markdown to ADF: ' +
+          (error instanceof Error ? error.message : 'Unknown error')
+      )
+    );
+    process.exit(1);
+  }
+
+  // Update issue description with spinner
+  const spinner = ora(`Updating description for ${taskId}...`).start();
+
+  try {
+    await updateIssueDescription(taskId, adfContent);
+    spinner.succeed(chalk.green(`Description updated successfully for ${taskId}`));
+    console.log(chalk.gray(`\nFile: ${absolutePath}`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to update description'));
+    console.error(
+      chalk.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.yellow('\nHint: Check that the task ID is correct'));
+    } else if (error instanceof Error && error.message.includes('403')) {
+      console.log(
+        chalk.yellow('\nHint: You may not have permission to edit this issue')
+      );
+    }
+
+    process.exit(1);
+  }
+}

package/src/lib/formatters.ts

@@ -0,0 +1,224 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { UserInfo, Project, TaskDetails, Status, JqlIssue } from './jira-client';
+import { formatTimestamp, truncate } from './utils';
+
+/**
+ * Create a styled table
+ */
+function createTable(headers: string[], colWidths?: number[]): Table.Table {
+  return new Table({
+    head: headers.map((h) => chalk.cyan.bold(h)),
+    style: {
+      head: [],
+      border: ['gray'],
+    },
+    colWidths,
+    wordWrap: true,
+  });
+}
+
+/**
+ * Format user info
+ */
+export function formatUserInfo(user: UserInfo): string {
+  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.green('Active') : chalk.red('Inactive')],
+    ['Time Zone', user.timeZone]
+  );
+
+  return '\n' + chalk.bold('User Information:') + '\n' + table.toString() + '\n';
+}
+
+/**
+ * Format projects list
+ */
+export function formatProjects(projects: Project[]): string {
+  if (projects.length === 0) {
+    return chalk.yellow('No projects found.');
+  }
+
+  const table = createTable(['Key', 'Name', 'Type', 'Lead'], [12, 35, 15, 25]);
+
+  projects.forEach((project) => {
+    table.push([
+      chalk.cyan(project.key),
+      truncate(project.name, 35),
+      project.projectTypeKey,
+      project.lead?.displayName || chalk.gray('N/A'),
+    ]);
+  });
+
+  let output = '\n' + chalk.bold(`Projects (${projects.length} total)`) + '\n\n';
+  output += table.toString() + '\n';
+
+  return output;
+}
+
+/**
+ * Format task details with comments
+ */
+export function formatTaskDetails(task: TaskDetails): string {
+  let output = '\n' + chalk.bold.cyan(`${task.key}: ${task.summary}`) + '\n\n';
+
+  // Basic info table
+  const infoTable = createTable(['Property', 'Value'], [15, 65]);
+
+  infoTable.push(
+    ['Status', chalk.green(task.status.name)],
+    ['Assignee', task.assignee?.displayName || chalk.gray('Unassigned')],
+    ['Reporter', task.reporter?.displayName || chalk.gray('N/A')],
+    ['Created', formatTimestamp(task.created)],
+    ['Updated', formatTimestamp(task.updated)]
+  );
+
+  output += infoTable.toString() + '\n\n';
+
+  // Parent Task
+  if (task.parent) {
+    output += chalk.bold('Parent Task:') + '\n';
+    const parentTable = createTable(['Key', 'Summary', 'Status'], [12, 50, 18]);
+    parentTable.push([
+      chalk.cyan(task.parent.key),
+      truncate(task.parent.summary, 50),
+      task.parent.status.name,
+    ]);
+    output += parentTable.toString() + '\n\n';
+  }
+
+  // Subtasks
+  if (task.subtasks && task.subtasks.length > 0) {
+    output += chalk.bold(`Subtasks (${task.subtasks.length}):`) + '\n';
+    const subtasksTable = createTable(['Key', 'Summary', 'Status'], [12, 50, 18]);
+    task.subtasks.forEach((subtask) => {
+      subtasksTable.push([
+        chalk.cyan(subtask.key),
+        truncate(subtask.summary, 50),
+        subtask.status.name,
+      ]);
+    });
+    output += subtasksTable.toString() + '\n\n';
+  }
+
+  // Description
+  if (task.description) {
+    output += chalk.bold('Description:') + '\n';
+    output += chalk.dim('─'.repeat(80)) + '\n';
+    output += task.description + '\n';
+    output += chalk.dim('─'.repeat(80)) + '\n\n';
+  }
+
+  // Comments
+  if (task.comments.length > 0) {
+    output += chalk.bold(`Comments (${task.comments.length}):`) + '\n\n';
+
+    task.comments.forEach((comment, index) => {
+      output += chalk.cyan(`${index + 1}. ${comment.author.displayName}`) +
+                chalk.gray(` - ${formatTimestamp(comment.created)}`) + '\n';
+      output += chalk.dim('─'.repeat(80)) + '\n';
+      output += comment.body + '\n';
+      output += chalk.dim('─'.repeat(80)) + '\n\n';
+    });
+  } else {
+    output += chalk.gray('No comments yet.\n\n');
+  }
+
+  return output;
+}
+
+/**
+ * Format project statuses list
+ */
+export function formatProjectStatuses(projectKey: string, statuses: Status[]): string {
+  if (statuses.length === 0) {
+    return chalk.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.white;
+    if (status.statusCategory.key.toLowerCase() === 'done') {
+      categoryColor = chalk.green;
+    } else if (status.statusCategory.key.toLowerCase() === 'indeterminate') {
+      categoryColor = chalk.yellow;
+    } else if (status.statusCategory.key.toLowerCase() === 'new') {
+      categoryColor = chalk.blue;
+    }
+
+    table.push([
+      chalk.cyan(status.name),
+      categoryColor(status.statusCategory.name),
+      truncate(status.description || chalk.gray('No description'), 45),
+    ]);
+  });
+
+  let output = '\n' + chalk.bold(`Project ${projectKey} - Available Statuses (${statuses.length} total)`) + '\n\n';
+  output += table.toString() + '\n';
+
+  return output;
+}
+
+/**
+ * Format JQL query results
+ */
+export function formatJqlResults(issues: JqlIssue[]): string {
+  if (issues.length === 0) {
+    return chalk.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.white;
+    const statusLower = issue.status.name.toLowerCase();
+    if (statusLower.includes('done') || statusLower.includes('closed') || statusLower.includes('resolved')) {
+      statusColor = chalk.green;
+    } else if (statusLower.includes('progress') || statusLower.includes('review')) {
+      statusColor = chalk.yellow;
+    }
+
+    // Color-code priority
+    let priorityColor = chalk.white;
+    const priorityName = issue.priority?.name || chalk.gray('None');
+    if (issue.priority) {
+      const priorityLower = issue.priority.name.toLowerCase();
+      if (priorityLower.includes('highest') || priorityLower.includes('high')) {
+        priorityColor = chalk.red;
+      } else if (priorityLower.includes('medium')) {
+        priorityColor = chalk.yellow;
+      } else if (priorityLower.includes('low')) {
+        priorityColor = chalk.blue;
+      }
+    }
+
+    table.push([
+      chalk.cyan(issue.key),
+      truncate(issue.summary, 40),
+      statusColor(issue.status.name),
+      issue.assignee ? truncate(issue.assignee.displayName, 20) : chalk.gray('Unassigned'),
+      typeof priorityName === 'string' ? priorityColor(priorityName) : priorityName,
+    ]);
+  });
+
+  let output = '\n' + chalk.bold(`Results (${issues.length} total)`) + '\n\n';
+  output += table.toString() + '\n';
+
+  return output;
+}

package/src/lib/jira-client.ts

@@ -0,0 +1,319 @@
+import { Version3Client } from 'jira.js';
+import { convertADFToMarkdown } from './utils';
+
+export interface UserInfo {
+  accountId: string;
+  displayName: string;
+  emailAddress: string;
+  active: boolean;
+  timeZone: string;
+}
+
+export interface Project {
+  id: string;
+  key: string;
+  name: string;
+  projectTypeKey: string;
+  lead?: {
+    displayName: string;
+  };
+}
+
+export interface Comment {
+  id: string;
+  author: {
+    displayName: string;
+    emailAddress?: string;
+  };
+  body: string;
+  created: string;
+  updated: string;
+}
+
+export interface Status {
+  id: string;
+  name: string;
+  description?: string;
+  statusCategory: {
+    id: string;
+    key: string;
+    name: string;
+  };
+}
+
+export interface LinkedIssue {
+  id: string;
+  key: string;
+  summary: string;
+  status: {
+    name: string;
+  };
+}
+
+export interface TaskDetails {
+  id: string;
+  key: string;
+  summary: string;
+  description?: string;
+  status: {
+    name: string;
+  };
+  assignee?: {
+    displayName: string;
+  };
+  reporter?: {
+    displayName: string;
+  };
+  created: string;
+  updated: string;
+  comments: Comment[];
+  parent?: LinkedIssue;
+  subtasks: LinkedIssue[];
+}
+
+export interface JqlIssue {
+  key: string;
+  summary: string;
+  status: {
+    name: string;
+  };
+  assignee: {
+    displayName: string;
+  } | null;
+  priority: {
+    name: string;
+  } | null;
+}
+
+let jiraClient: Version3Client | null = null;
+
+/**
+ * Get or create Jira client instance
+ */
+export function getJiraClient(): Version3Client {
+  if (!jiraClient) {
+    jiraClient = new 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
+ */
+export async function getCurrentUser(): Promise<UserInfo> {
+  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
+ */
+export async function getProjects(): Promise<Project[]> {
+  const client = getJiraClient();
+  const response = await client.projects.searchProjects({
+    expand: 'lead',
+  });
+
+  return response.values.map((project: any) => ({
+    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
+ */
+export async function getTaskWithDetails(taskId: string): Promise<TaskDetails> {
+  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: Comment[] = issue.fields.comment?.comments?.map((comment: any) => ({
+    id: comment.id,
+    author: {
+      displayName: comment.author?.displayName || 'Unknown',
+      emailAddress: comment.author?.emailAddress,
+    },
+    body: convertADFToMarkdown(comment.body),
+    created: comment.created || '',
+    updated: comment.updated || '',
+  })) || [];
+
+  // Convert description from ADF to Markdown
+  const descriptionMarkdown = convertADFToMarkdown(issue.fields.description);
+  const description = descriptionMarkdown || undefined;
+
+  // Extract parent if exists
+  const parent: LinkedIssue | undefined = 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: LinkedIssue[] = issue.fields.subtasks?.map((subtask: any) => ({
+    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
+ */
+export async function getProjectStatuses(projectIdOrKey: string): Promise<Status[]> {
+  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<string, Status>();
+
+  statuses.forEach((issueTypeStatuses: any) => {
+    issueTypeStatuses.statuses?.forEach((status: any) => {
+      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
+ */
+export async function searchIssuesByJql(jqlQuery: string, maxResults: number): Promise<JqlIssue[]> {
+  const client = getJiraClient();
+
+  const response = await client.issueSearch.searchForIssuesUsingJqlEnhancedSearch({
+    jql: jqlQuery,
+    maxResults,
+    fields: ['summary', 'status', 'assignee', 'priority'],
+  });
+
+  return response.issues?.map((issue: any) => ({
+    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
+ */
+export async function updateIssueDescription(
+  taskId: string,
+  adfContent: any
+): Promise<void> {
+  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
+ */
+export async function addIssueComment(
+  taskId: string,
+  adfContent: any
+): Promise<void> {
+  const client = getJiraClient();
+  await client.issueComments.addComment({
+    issueIdOrKey: taskId,
+    comment: adfContent,
+  });
+}

package/src/lib/settings.ts

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+export interface Settings {
+  projects: string[];
+  commands: string[];
+}
+
+let cachedSettings: Settings | null = null;
+
+export function loadSettings(): Settings {
+  if (cachedSettings) {
+    return cachedSettings;
+  }
+
+  const settingsPath = path.join(process.cwd(), 'settings.yaml');
+
+  if (!fs.existsSync(settingsPath)) {
+    console.warn('Warning: settings.yaml not found. Using default settings (all allowed).');
+    cachedSettings = {
+      projects: ['all'],
+      commands: ['all']
+    };
+    return cachedSettings;
+  }
+
+  try {
+    const fileContents = fs.readFileSync(settingsPath, 'utf8');
+    const settings = yaml.load(fileContents) as Settings;
+
+    cachedSettings = {
+      projects: settings.projects || ['all'],
+      commands: settings.commands || ['all']
+    };
+
+    return cachedSettings;
+  } catch (error) {
+    console.error('Error loading settings.yaml:', error);
+    process.exit(1);
+  }
+}
+
+export function isProjectAllowed(projectKey: string): boolean {
+  const settings = loadSettings();
+
+  if (settings.projects.includes('all')) {
+    return true;
+  }
+
+  return settings.projects.includes(projectKey);
+}
+
+export function isCommandAllowed(commandName: string): boolean {
+  const settings = loadSettings();
+
+  if (settings.commands.includes('all')) {
+    return true;
+  }
+
+  return settings.commands.includes(commandName);
+}
+
+export function getAllowedProjects(): string[] {
+  const settings = loadSettings();
+  return settings.projects;
+}
+
+export function getAllowedCommands(): string[] {
+  const settings = loadSettings();
+  return settings.commands;
+}
+
+// For testing purposes only
+export function __resetCache__(): void {
+  cachedSettings = null;
+}