jira-ai 0.2.11 → 0.3.0

package/dist/cli.js

@@ -16,6 +16,7 @@ const list_issue_types_1 = require("./commands/list-issue-types");
 const run_jql_1 = require("./commands/run-jql");
 const update_description_1 = require("./commands/update-description");
 const add_comment_1 = require("./commands/add-comment");
+const create_task_1 = require("./commands/create-task");
 const about_1 = require("./commands/about");
 const auth_1 = require("./commands/auth");
 const settings_1 = require("./lib/settings");
@@ -95,6 +96,15 @@ program
     .requiredOption('--file-path <path>', 'Path to Markdown file')
     .requiredOption('--issue-key <key>', 'Jira issue key (e.g., PS-123)')
     .action(withPermission('add-comment', add_comment_1.addCommentCommand));
+// Create task command
+program
+    .command('create-task')
+    .description('Create a new Jira issue')
+    .requiredOption('--title <title>', 'Issue title/summary')
+    .requiredOption('--project <project>', 'Project key (e.g., PROJ)')
+    .requiredOption('--issue-type <type>', 'Issue type (e.g., Task, Epic, Subtask)')
+    .option('--parent <key>', 'Parent issue key (required for subtasks)')
+    .action(withPermission('create-task', create_task_1.createTaskCommand));
 // About command (always allowed)
 program
     .command('about')

package/dist/commands/create-task.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskCommand = createTaskCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const jira_client_1 = require("../lib/jira-client");
+async function createTaskCommand(options) {
+    const { title, project, issueType, parent } = options;
+    // Validate required fields
+    if (!title || title.trim() === '') {
+        console.error(chalk_1.default.red('\nError: Title is required (use --title)'));
+        process.exit(1);
+    }
+    if (!project || project.trim() === '') {
+        console.error(chalk_1.default.red('\nError: Project is required (use --project)'));
+        process.exit(1);
+    }
+    if (!issueType || issueType.trim() === '') {
+        console.error(chalk_1.default.red('\nError: Issue type is required (use --issue-type)'));
+        process.exit(1);
+    }
+    // Create issue with spinner
+    const spinner = (0, ora_1.default)(`Creating ${issueType} in project ${project}...`).start();
+    try {
+        const result = await (0, jira_client_1.createIssue)(project, title, issueType, parent);
+        spinner.succeed(chalk_1.default.green(`Issue created successfully: ${result.key}`));
+        console.log(chalk_1.default.gray(`\nTitle: ${title}`));
+        console.log(chalk_1.default.gray(`Project: ${project}`));
+        console.log(chalk_1.default.gray(`Issue Type: ${issueType}`));
+        if (parent) {
+            console.log(chalk_1.default.gray(`Parent: ${parent}`));
+        }
+        console.log(chalk_1.default.cyan(`\nIssue Key: ${result.key}`));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('Failed to create issue'));
+        console.error(chalk_1.default.red('\nError: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        // Provide helpful hints based on error
+        if (error instanceof Error) {
+            if (error.message.includes('project') || error.message.includes('Project')) {
+                console.log(chalk_1.default.yellow('\nHint: Check that the project key is correct'));
+                console.log(chalk_1.default.yellow('Use "jira-ai projects" to see available projects'));
+            }
+            else if (error.message.includes('issue type') || error.message.includes('issuetype')) {
+                console.log(chalk_1.default.yellow('\nHint: Check that the issue type is correct'));
+                console.log(chalk_1.default.yellow(`Use "jira-ai list-issue-types ${project}" to see available issue types`));
+            }
+            else if (error.message.includes('parent') || error.message.includes('Parent')) {
+                console.log(chalk_1.default.yellow('\nHint: Check that the parent issue key is correct'));
+                console.log(chalk_1.default.yellow('Parent issues are required for subtasks'));
+            }
+            else if (error.message.includes('403')) {
+                console.log(chalk_1.default.yellow('\nHint: You may not have permission to create issues in this project'));
+            }
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/jira-client.js

@@ -10,6 +10,7 @@ exports.searchIssuesByJql = searchIssuesByJql;
 exports.updateIssueDescription = updateIssueDescription;
 exports.addIssueComment = addIssueComment;
 exports.getProjectIssueTypes = getProjectIssueTypes;
+exports.createIssue = createIssue;
 const jira_js_1 = require("jira.js");
 const utils_1 = require("./utils");
 const auth_storage_1 = require("./auth-storage");
@@ -270,3 +271,35 @@ async function getProjectIssueTypes(projectIdOrKey) {
         hierarchyLevel: issueType.hierarchyLevel || 0,
     })) || [];
 }
+/**
+ * Create a new issue
+ * @param projectKey - The project key (e.g., "PROJ")
+ * @param summary - The issue title/summary
+ * @param issueTypeName - The issue type name (e.g., "Task", "Epic", "Subtask")
+ * @param parentKey - Optional parent issue key for subtasks
+ */
+async function createIssue(projectKey, summary, issueTypeName, parentKey) {
+    const client = getJiraClient();
+    const fields = {
+        project: {
+            key: projectKey,
+        },
+        summary,
+        issuetype: {
+            name: issueTypeName,
+        },
+    };
+    // Add parent field if this is a subtask
+    if (parentKey) {
+        fields.parent = {
+            key: parentKey,
+        };
+    }
+    const response = await client.issues.createIssue({
+        fields,
+    });
+    return {
+        key: response.key || '',
+        id: response.id || '',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jira-ai",
-  "version": "0.2.11",
+  "version": "0.3.0",
   "description": "CLI tool for interacting with Atlassian Jira",
   "main": "dist/cli.js",
   "bin": {

package/settings.yaml

@@ -11,7 +11,7 @@ projects:
   # - all
 
 # Commands: List of allowed commands (use "all" to allow all commands)
-# Available commands: me, projects, task-with-details, project-statuses, list-issue-types, run-jql, update-description, add-comment, about
+# Available commands: me, projects, task-with-details, project-statuses, list-issue-types, run-jql, update-description, add-comment, create-task, about
 commands:
   - me
   - projects
@@ -23,3 +23,4 @@ commands:
   - list-issue-types
   - update-description
   - add-comment
+  - create-task

package/src/cli.ts

@@ -12,6 +12,7 @@ import { listIssueTypesCommand } from './commands/list-issue-types';
 import { runJqlCommand } from './commands/run-jql';
 import { updateDescriptionCommand } from './commands/update-description';
 import { addCommentCommand } from './commands/add-comment';
+import { createTaskCommand } from './commands/create-task';
 import { aboutCommand } from './commands/about';
 import { authCommand } from './commands/auth';
 import { isCommandAllowed, getAllowedCommands } from './lib/settings';
@@ -107,6 +108,16 @@ program
   .requiredOption('--issue-key <key>', 'Jira issue key (e.g., PS-123)')
   .action(withPermission('add-comment', addCommentCommand));
 
+// Create task command
+program
+  .command('create-task')
+  .description('Create a new Jira issue')
+  .requiredOption('--title <title>', 'Issue title/summary')
+  .requiredOption('--project <project>', 'Project key (e.g., PROJ)')
+  .requiredOption('--issue-type <type>', 'Issue type (e.g., Task, Epic, Subtask)')
+  .option('--parent <key>', 'Parent issue key (required for subtasks)')
+  .action(withPermission('create-task', createTaskCommand));
+
 // About command (always allowed)
 program
   .command('about')

package/src/commands/create-task.ts

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { createIssue } from '../lib/jira-client';
+
+export async function createTaskCommand(
+  options: {
+    title: string;
+    project: string;
+    issueType: string;
+    parent?: string;
+  }
+): Promise<void> {
+  const { title, project, issueType, parent } = options;
+
+  // Validate required fields
+  if (!title || title.trim() === '') {
+    console.error(chalk.red('\nError: Title is required (use --title)'));
+    process.exit(1);
+  }
+
+  if (!project || project.trim() === '') {
+    console.error(chalk.red('\nError: Project is required (use --project)'));
+    process.exit(1);
+  }
+
+  if (!issueType || issueType.trim() === '') {
+    console.error(chalk.red('\nError: Issue type is required (use --issue-type)'));
+    process.exit(1);
+  }
+
+  // Create issue with spinner
+  const spinner = ora(`Creating ${issueType} in project ${project}...`).start();
+
+  try {
+    const result = await createIssue(project, title, issueType, parent);
+
+    spinner.succeed(chalk.green(`Issue created successfully: ${result.key}`));
+    console.log(chalk.gray(`\nTitle: ${title}`));
+    console.log(chalk.gray(`Project: ${project}`));
+    console.log(chalk.gray(`Issue Type: ${issueType}`));
+    if (parent) {
+      console.log(chalk.gray(`Parent: ${parent}`));
+    }
+    console.log(chalk.cyan(`\nIssue Key: ${result.key}`));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create issue'));
+    console.error(
+      chalk.red(
+        '\nError: ' + (error instanceof Error ? error.message : 'Unknown error')
+      )
+    );
+
+    // Provide helpful hints based on error
+    if (error instanceof Error) {
+      if (error.message.includes('project') || error.message.includes('Project')) {
+        console.log(chalk.yellow('\nHint: Check that the project key is correct'));
+        console.log(chalk.yellow('Use "jira-ai projects" to see available projects'));
+      } else if (error.message.includes('issue type') || error.message.includes('issuetype')) {
+        console.log(chalk.yellow('\nHint: Check that the issue type is correct'));
+        console.log(chalk.yellow(`Use "jira-ai list-issue-types ${project}" to see available issue types`));
+      } else if (error.message.includes('parent') || error.message.includes('Parent')) {
+        console.log(chalk.yellow('\nHint: Check that the parent issue key is correct'));
+        console.log(chalk.yellow('Parent issues are required for subtasks'));
+      } else if (error.message.includes('403')) {
+        console.log(
+          chalk.yellow('\nHint: You may not have permission to create issues in this project')
+        );
+      }
+    }
+
+    process.exit(1);
+  }
+}

package/src/lib/jira-client.ts

@@ -383,3 +383,45 @@ export async function getProjectIssueTypes(projectIdOrKey: string): Promise<Issu
     hierarchyLevel: issueType.hierarchyLevel || 0,
   })) || [];
 }
+
+/**
+ * Create a new issue
+ * @param projectKey - The project key (e.g., "PROJ")
+ * @param summary - The issue title/summary
+ * @param issueTypeName - The issue type name (e.g., "Task", "Epic", "Subtask")
+ * @param parentKey - Optional parent issue key for subtasks
+ */
+export async function createIssue(
+  projectKey: string,
+  summary: string,
+  issueTypeName: string,
+  parentKey?: string
+): Promise<{ key: string; id: string }> {
+  const client = getJiraClient();
+
+  const fields: any = {
+    project: {
+      key: projectKey,
+    },
+    summary,
+    issuetype: {
+      name: issueTypeName,
+    },
+  };
+
+  // Add parent field if this is a subtask
+  if (parentKey) {
+    fields.parent = {
+      key: parentKey,
+    };
+  }
+
+  const response = await client.issues.createIssue({
+    fields,
+  });
+
+  return {
+    key: response.key || '',
+    id: response.id || '',
+  };
+}

package/tests/create-task.test.ts

@@ -0,0 +1,199 @@
+import { createTaskCommand } from '../src/commands/create-task';
+import * as jiraClient from '../src/lib/jira-client';
+
+// Mock dependencies
+jest.mock('../src/lib/jira-client');
+jest.mock('../src/lib/utils');
+jest.mock('ora', () => {
+  return jest.fn(() => ({
+    start: jest.fn().mockReturnThis(),
+    succeed: jest.fn().mockReturnThis(),
+    fail: jest.fn().mockReturnThis()
+  }));
+});
+
+const mockJiraClient = jiraClient as jest.Mocked<typeof jiraClient>;
+
+describe('Create Task Command', () => {
+  const mockOptions = {
+    title: 'Test Task Title',
+    project: 'TEST',
+    issueType: 'Task',
+  };
+
+  const mockResponse = {
+    key: 'TEST-123',
+    id: '10001',
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    console.log = jest.fn();
+    console.error = jest.fn();
+
+    // Setup default mock
+    mockJiraClient.createIssue = jest.fn().mockResolvedValue(mockResponse);
+  });
+
+  it('should successfully create a task', async () => {
+    await createTaskCommand(mockOptions);
+
+    expect(mockJiraClient.createIssue).toHaveBeenCalledWith(
+      'TEST',
+      'Test Task Title',
+      'Task',
+      undefined
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('TEST-123'));
+  });
+
+  it('should create a task with parent issue', async () => {
+    const optionsWithParent = {
+      ...mockOptions,
+      parent: 'TEST-100',
+    };
+
+    await createTaskCommand(optionsWithParent);
+
+    expect(mockJiraClient.createIssue).toHaveBeenCalledWith(
+      'TEST',
+      'Test Task Title',
+      'Task',
+      'TEST-100'
+    );
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Parent: TEST-100'));
+  });
+
+  it('should exit with error when title is empty', async () => {
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(
+      createTaskCommand({ ...mockOptions, title: '' })
+    ).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Title is required')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error when project is empty', async () => {
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(
+      createTaskCommand({ ...mockOptions, project: '' })
+    ).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Project is required')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error when issue type is empty', async () => {
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(
+      createTaskCommand({ ...mockOptions, issueType: '' })
+    ).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Issue type is required')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error and hint when project not found', async () => {
+    const apiError = new Error('Project does not exist');
+    mockJiraClient.createIssue = jest.fn().mockRejectedValue(apiError);
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(createTaskCommand(mockOptions)).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Project does not exist')
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Check that the project key is correct')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error and hint when issue type is invalid', async () => {
+    const apiError = new Error('Invalid issue type specified');
+    mockJiraClient.createIssue = jest.fn().mockRejectedValue(apiError);
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(createTaskCommand(mockOptions)).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Invalid issue type specified')
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Check that the issue type is correct')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error and hint when parent issue is invalid', async () => {
+    const apiError = new Error('Parent issue not found');
+    mockJiraClient.createIssue = jest.fn().mockRejectedValue(apiError);
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(
+      createTaskCommand({ ...mockOptions, parent: 'TEST-999' })
+    ).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Parent issue not found')
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Check that the parent issue key is correct')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error and hint when permission denied (403)', async () => {
+    const apiError = new Error('Permission denied (403)');
+    mockJiraClient.createIssue = jest.fn().mockRejectedValue(apiError);
+    const processExitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {
+      throw new Error('Process exit');
+    });
+
+    await expect(createTaskCommand(mockOptions)).rejects.toThrow('Process exit');
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Permission denied (403)')
+    );
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('You may not have permission to create issues')
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    processExitSpy.mockRestore();
+  });
+});