jira-ai 0.9.96 → 0.9.97

package/README.md

@@ -63,6 +63,35 @@ See all available commands:
 jira-ai --help
 ```
 
+## JSON Output Mode
+
+All commands support structured JSON output via global flags. This is designed for AI agents and scripting integrations where parsed data is more useful than formatted tables.
+
+### `--json`
+
+Outputs pretty-printed JSON (2-space indentation):
+```bash
+jira-ai --json issue get PROJ-123
+jira-ai --json project list
+jira-ai --json issue search "project = PROJ AND status = Open"
+```
+
+### `--json-compact`
+
+Outputs single-line JSON for maximum token efficiency — ideal for AI agent workflows:
+```bash
+jira-ai --json-compact issue get PROJ-123
+```
+
+### Error handling in JSON mode
+
+Errors are returned as structured JSON to stdout:
+```json
+{ "error": true, "message": "Issue not found", "hints": ["Check the issue key"], "exitCode": 1 }
+```
+
+Default table output is unchanged when neither flag is used.
+
 ### Rich Issue Management
 
 Create issues with detailed field support:

package/dist/cli.js

@@ -34,6 +34,7 @@ import { checkForUpdate, formatUpdateMessage, checkForUpdateSync } from './lib/u
 import { CliError } from './types/errors.js';
 import { CommandError } from './lib/errors.js';
 import { ui } from './lib/ui.js';
+import { initJsonMode, outputError } from './lib/json-mode.js';
 import { CreateTaskSchema, UpdateDescriptionSchema, ProjectFieldsSchema, ConfluenceAddCommentSchema, RunJqlSchema, GetPersonWorklogSchema, GetIssueStatisticsSchema, EpicListSchema, EpicCreateSchema, EpicUpdateSchema, EpicLinkSchema, EpicMaxSchema, validateOptions, IssueKeySchema, ProjectKeySchema, TimeframeSchema } from './lib/validation.js';
 import { realpathSync } from 'fs';
 // Create CLI program
@@ -42,6 +43,8 @@ program
     .name('jira-ai')
     .description('CLI tool for interacting with Atlassian Jira')
     .version(getVersion())
+    .option('--json', 'Output as JSON')
+    .option('--json-compact', 'Output as compact JSON')
     .addHelpText('after', () => {
     const latestVersion = checkForUpdateSync();
     if (latestVersion) {
@@ -506,6 +509,7 @@ export function configureCommandVisibility(program) {
 // Parse command line arguments
 export async function main() {
     try {
+        initJsonMode();
         // Background update check (non-blocking for the user)
         checkForUpdate().catch(() => { });
         configureCommandVisibility(program);
@@ -514,30 +518,16 @@ export async function main() {
     catch (error) {
         ui.failSpinner();
         if (error instanceof CommandError) {
-            console.error(chalk.red(`\n❌ Error: ${error.message}`));
-            if (error.hints.length > 0) {
-                error.hints.forEach(hint => {
-                    console.error(chalk.yellow(`   Hint: ${hint}`));
-                });
-            }
-            console.log(); // Add a newline
-            process.exit(error.exitCode);
+            outputError(error.message, error.hints, error.exitCode);
         }
         else if (error instanceof CliError) {
-            console.error(chalk.red(`\n❌ ${error.message}\n`));
-            process.exit(1);
+            outputError(error.message, [], 1);
         }
         else if (error instanceof Error) {
-            console.error(chalk.red(`\n💥 Unexpected Error: ${error.message}`));
-            if (process.env.DEBUG) {
-                console.error(chalk.gray(error.stack));
-            }
-            console.error(chalk.gray('\nPlease report this issue if it persists.\n'));
-            process.exit(1);
+            outputError(`Unexpected Error: ${error.message}`, ['Please report this issue if it persists.'], 1);
         }
         else {
-            console.error(chalk.red(`\n💥 An unknown error occurred: ${String(error)}\n`));
-            process.exit(1);
+            outputError(`An unknown error occurred: ${String(error)}`, [], 1);
         }
     }
 }

package/dist/commands/about.js

@@ -1,18 +1,23 @@
 import chalk from 'chalk';
 import { getVersion } from '../lib/utils.js';
 import { checkForUpdate, formatUpdateMessage } from '../lib/update-check.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function aboutCommand() {
-    console.log(chalk.bold.cyan('\n📋 Jira AI\n'));
-    console.log(`${chalk.bold('Version:')} ${getVersion()}`);
-    console.log(`${chalk.bold('GitHub:')}  https://github.com/festoinc/jira-ai\n`);
+    const version = getVersion();
+    let latestVersion = null;
     try {
-        const latestVersion = await checkForUpdate();
-        if (latestVersion) {
-            console.log(formatUpdateMessage(latestVersion));
-            console.log();
-        }
+        latestVersion = await checkForUpdate() ?? null;
     }
     catch (error) {
         // Ignore update check errors in about command
     }
+    outputResult({ version, updateAvailable: latestVersion ?? undefined }, (data) => {
+        let out = chalk.bold.cyan('\n📋 Jira AI\n');
+        out += `${chalk.bold('Version:')} ${data.version}\n`;
+        out += `${chalk.bold('GitHub:')}  https://github.com/festoinc/jira-ai\n`;
+        if (data.updateAvailable) {
+            out += `\n${formatUpdateMessage(data.updateAvailable)}\n`;
+        }
+        return out;
+    });
 }

package/dist/commands/add-comment.js

@@ -7,6 +7,7 @@ import { processMentionsInADF } from '../lib/adf-mentions.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, AddCommentSchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function addCommentCommand(options) {
     // Validate options
     validateOptions(AddCommentSchema, options);
@@ -47,7 +48,7 @@ export async function addCommentCommand(options) {
     try {
         await addIssueComment(issueKey, adfContent);
         ui.succeedSpinner(chalk.green(`Comment added successfully to ${issueKey}`));
-        console.log(chalk.gray(`\nFile: ${absolutePath}`));
+        outputResult({ success: true, issueKey, file: absolutePath }, (data) => chalk.gray(`\nFile: ${data.file}`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/add-label.js

@@ -3,6 +3,7 @@ import { addIssueLabels, validateIssuePermissions } from '../lib/jira-client.js'
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, IssueKeySchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function addLabelCommand(taskId, labelsString) {
     // Validate input
     validateOptions(IssueKeySchema, taskId);
@@ -21,8 +22,7 @@ export async function addLabelCommand(taskId, labelsString) {
     try {
         await addIssueLabels(taskId, labels);
         ui.succeedSpinner(chalk.green(`Labels added successfully to ${taskId}`));
-        console.log(chalk.gray(`
-Labels: ${labels.join(', ')}`));
+        outputResult({ success: true, issueKey: taskId, labels }, (data) => chalk.gray(`\nLabels: ${data.labels.join(', ')}`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/auth.js

@@ -6,6 +6,7 @@ import { createTemporaryClient } from '../lib/jira-client.js';
 import { saveCredentials, clearCredentials } from '../lib/auth-storage.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 /**
  * Auto-discover the Atlassian Cloud ID for a given site hostname.
  */
@@ -28,7 +29,7 @@ async function discoverCloudId(host) {
 }
 export async function logoutCommand() {
     clearCredentials();
-    console.log(chalk.green('Successfully logged out. Authentication credentials cleared.'));
+    outputResult({ success: true, message: 'Successfully logged out. Authentication credentials cleared.' }, (data) => chalk.green(data.message));
 }
 export async function authCommand(options = {}) {
     if (options.logout) {
@@ -98,7 +99,9 @@ export async function authCommand(options = {}) {
         }
     }
     if (!host || !email || !apiToken) {
-        console.log(chalk.cyan('\n--- Jira Authentication Setup ---\n'));
+        if (!isJsonMode()) {
+            console.log(chalk.cyan('\n--- Jira Authentication Setup ---\n'));
+        }
         try {
             host = await ask('Jira URL (e.g., https://your-domain.atlassian.net): ');
             if (!host) {
@@ -139,13 +142,16 @@ export async function authCommand(options = {}) {
         const tempClient = createTemporaryClient(host, email, apiToken, { authType, cloudId });
         const user = await tempClient.myself.getCurrentUser();
         ui.succeedSpinner(chalk.green('Authentication successful!'));
-        console.log(chalk.blue(`\nWelcome, ${user.displayName} (${user.emailAddress})`));
-        if (authType === 'service_account') {
-            console.log(chalk.gray(`Auth type: service_account (via api.atlassian.com gateway)`));
-        }
         saveCredentials({ host, email, apiToken, authType, cloudId });
-        console.log(chalk.green('\nCredentials saved successfully to ~/.jira-ai/config.json'));
-        console.log(chalk.gray('These credentials will be used for future commands on this machine.'));
+        outputResult({ success: true, displayName: user.displayName, email: user.emailAddress, authType }, (data) => {
+            let out = chalk.blue(`\nWelcome, ${data.displayName} (${data.email})`);
+            if (data.authType === 'service_account') {
+                out += `\n${chalk.gray('Auth type: service_account (via api.atlassian.com gateway)')}`;
+            }
+            out += `\n${chalk.green('\nCredentials saved successfully to ~/.jira-ai/config.json')}`;
+            out += `\n${chalk.gray('These credentials will be used for future commands on this machine.')}`;
+            return out;
+        });
     }
     catch (error) {
         const hints = [];

package/dist/commands/confluence.js

@@ -7,6 +7,7 @@ import { formatConfluencePage, formatConfluenceSpaces, formatConfluencePageHiera
 import { ui } from '../lib/ui.js';
 import { CommandError } from '../lib/errors.js';
 import { isConfluenceSpaceAllowed } from '../lib/settings.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function confluenceCreatePageCommand(space, title, parentPage, options = {}) {
     // Validate space key
     if (!isConfluenceSpaceAllowed(space)) {
@@ -16,13 +17,12 @@ export async function confluenceCreatePageCommand(space, title, parentPage, opti
     try {
         const result = await createPage(space, title, parentPage, { returnBoth: options.returnBothUrls });
         ui.succeedSpinner(chalk.green('Confluence page created successfully'));
-        if (typeof result === 'object') {
-            console.log(chalk.cyan(`\nFull URL:  ${result.url}`));
-            console.log(chalk.cyan(`Short URL: ${result.shortUrl}`));
-        }
-        else {
-            console.log(chalk.cyan(`\nURL: ${result}`));
-        }
+        outputResult(typeof result === 'object' ? result : { url: result }, (data) => {
+            if ('shortUrl' in data) {
+                return chalk.cyan(`\nFull URL:  ${data.url}\nShort URL: ${data.shortUrl}`);
+            }
+            return chalk.cyan(`\nURL: ${data.url}`);
+        });
     }
     catch (error) {
         ui.failSpinner();
@@ -81,8 +81,7 @@ export async function confluenceAddCommentCommand(url, options) {
     try {
         await addPageComment(url, adfContent);
         ui.succeedSpinner(chalk.green('Comment added successfully to Confluence page'));
-        console.log(chalk.gray(`\nPage: ${url}`));
-        console.log(chalk.gray(`File: ${absolutePath}`));
+        outputResult({ success: true, page: url, file: absolutePath }, (data) => chalk.gray(`\nPage: ${data.page}\nFile: ${data.file}`));
     }
     catch (error) {
         ui.failSpinner();
@@ -123,7 +122,7 @@ export async function confluenceGetPageCommand(url, options = {}) {
             throw new CommandError(`Access to Confluence space '${page.space}' is restricted by your settings.`);
         }
         ui.succeedSpinner(chalk.green('Confluence page details retrieved'));
-        console.log(formatConfluencePage(page, comments));
+        outputResult({ page, comments }, (data) => formatConfluencePage(data.page, data.comments));
     }
     catch (error) {
         ui.failSpinner();
@@ -152,15 +151,20 @@ export async function confluenceListSpacesCommand() {
         const allowedSpaces = spaces.filter(space => isConfluenceSpaceAllowed(space.key));
         if (allowedSpaces.length === 0) {
             ui.failSpinner('No allowed Confluence spaces found.');
-            console.log(chalk.yellow('\nHint: Add allowed spaces to your settings.yaml under "allowed-confluence-spaces".'));
-            console.log(chalk.gray('Example:'));
-            console.log(chalk.gray('  allowed-confluence-spaces:'));
-            console.log(chalk.gray('    - SPACE1'));
-            console.log(chalk.gray('    - SPACE2'));
+            if (!isJsonMode()) {
+                console.log(chalk.yellow('\nHint: Add allowed spaces to your settings.yaml under "allowed-confluence-spaces".'));
+                console.log(chalk.gray('Example:'));
+                console.log(chalk.gray('  allowed-confluence-spaces:'));
+                console.log(chalk.gray('    - SPACE1'));
+                console.log(chalk.gray('    - SPACE2'));
+            }
+            else {
+                outputResult([]);
+            }
             return;
         }
         ui.succeedSpinner(chalk.green('Confluence spaces retrieved'));
-        console.log(formatConfluenceSpaces(allowedSpaces));
+        outputResult(allowedSpaces, formatConfluenceSpaces);
     }
     catch (error) {
         ui.failSpinner();
@@ -176,7 +180,7 @@ export async function confluenceGetSpacePagesHierarchyCommand(spaceKey) {
     try {
         const hierarchy = await getSpacePagesHierarchy(spaceKey);
         ui.succeedSpinner(chalk.green('Confluence page hierarchy retrieved'));
-        console.log(formatConfluencePageHierarchy(hierarchy));
+        outputResult(hierarchy, formatConfluencePageHierarchy);
     }
     catch (error) {
         ui.failSpinner();
@@ -224,8 +228,7 @@ export async function confluenceUpdateDescriptionCommand(url, options) {
     try {
         await updatePageContent(url, adfContent);
         ui.succeedSpinner(chalk.green('Confluence page content updated successfully'));
-        console.log(chalk.gray(`\nPage: ${url}`));
-        console.log(chalk.gray(`File: ${absolutePath}`));
+        outputResult({ success: true, page: url, file: absolutePath }, (data) => chalk.gray(`\nPage: ${data.page}\nFile: ${data.file}`));
     }
     catch (error) {
         ui.failSpinner();
@@ -256,7 +259,7 @@ export async function confluenceSearchCommand(query, options = {}) {
             return isConfluenceSpaceAllowed(result.space);
         });
         ui.succeedSpinner(chalk.green('Confluence search completed'));
-        console.log(formatConfluenceSearchResults(filteredResults));
+        outputResult(filteredResults, formatConfluenceSearchResults);
     }
     catch (error) {
         ui.failSpinner();

package/dist/commands/create-issue-link.js

@@ -3,6 +3,7 @@ import { createIssueLink, validateIssuePermissions } from '../lib/jira-client.js
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, IssueKeySchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function createIssueLinkCommand(inwardKey, linkType, outwardKey) {
     validateOptions(IssueKeySchema, inwardKey);
     validateOptions(IssueKeySchema, outwardKey);
@@ -12,8 +13,7 @@ export async function createIssueLinkCommand(inwardKey, linkType, outwardKey) {
     try {
         await createIssueLink(inwardKey, outwardKey, linkType.trim());
         ui.succeedSpinner(chalk.green(`Link created successfully`));
-        console.log(chalk.gray(`
-${inwardKey} --[${linkType.trim()}]--> ${outwardKey}`));
+        outputResult({ success: true, inwardKey, linkType: linkType.trim(), outwardKey }, (data) => chalk.gray(`\n${data.inwardKey} --[${data.linkType}]--> ${data.outwardKey}`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/create-task.js

@@ -7,6 +7,7 @@ import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, CreateTaskSchema } from '../lib/validation.js';
 import { isCommandAllowed, isProjectAllowed } from '../lib/settings.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function createTaskCommand(options) {
     validateOptions(CreateTaskSchema, options);
     const { title, project, issueType, parent, priority, description, descriptionFile, labels, component, fixVersion, dueDate, assignee, customField } = options;
@@ -85,13 +86,16 @@ export async function createTaskCommand(options) {
             ...issueFields,
         });
         ui.succeedSpinner(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}`));
+        outputResult({ key: result.key, title, project, issueType, parent }, (data) => {
+            let out = chalk.gray(`\nTitle: ${data.title}`);
+            out += `\n${chalk.gray(`Project: ${data.project}`)}`;
+            out += `\n${chalk.gray(`Issue Type: ${data.issueType}`)}`;
+            if (data.parent) {
+                out += `\n${chalk.gray(`Parent: ${data.parent}`)}`;
+            }
+            out += `\n${chalk.cyan(`\nIssue Key: ${data.key}`)}`;
+            return out;
+        });
     }
     catch (error) {
         const errorMsg = error.message?.toLowerCase() || '';

package/dist/commands/delete-issue-link.js

@@ -3,6 +3,7 @@ import { getIssueLinks, deleteIssueLink, validateIssuePermissions } from '../lib
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, IssueKeySchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function deleteIssueLinkCommand(sourceKey, targetKey) {
     validateOptions(IssueKeySchema, sourceKey);
     validateOptions(IssueKeySchema, targetKey);
@@ -26,7 +27,7 @@ export async function deleteIssueLinkCommand(sourceKey, targetKey) {
         ui.startSpinner(`Deleting link ${linkId}...`);
         await deleteIssueLink(linkId);
         ui.succeedSpinner(chalk.green(`Link deleted successfully`));
-        console.log(chalk.gray(`\nRemoved: ${sourceKey} <--> ${targetKey} (${matchingLinks[0].type.name})`));
+        outputResult({ success: true, sourceKey, targetKey, linkType: matchingLinks[0].type.name }, (data) => chalk.gray(`\nRemoved: ${data.sourceKey} <--> ${data.targetKey} (${data.linkType})`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/delete-label.js

@@ -3,6 +3,7 @@ import { removeIssueLabels, validateIssuePermissions } from '../lib/jira-client.
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, IssueKeySchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function deleteLabelCommand(taskId, labelsString) {
     // Validate input
     validateOptions(IssueKeySchema, taskId);
@@ -21,8 +22,7 @@ export async function deleteLabelCommand(taskId, labelsString) {
     try {
         await removeIssueLabels(taskId, labels);
         ui.succeedSpinner(chalk.green(`Labels removed successfully from ${taskId}`));
-        console.log(chalk.gray(`
-Labels: ${labels.join(', ')}`));
+        outputResult({ success: true, issueKey: taskId, labels }, (data) => chalk.gray(`\nLabels: ${data.labels.join(', ')}`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/epic.js

@@ -1,20 +1,21 @@
 import chalk from 'chalk';
-import { listEpics, getEpic, createEpic, updateEpic, getEpicIssues, linkIssueToEpic, unlinkIssueFromEpic, getEpicProgress, } from '../lib/jira-client.js';
+import { getEpics, getEpic, createEpic, updateEpic, getEpicIssues, linkIssueToEpic, unlinkIssueFromEpic, getEpicProgress, } from '../lib/jira-client.js';
 import { formatEpicList, formatEpicDetails, formatEpicProgress, formatEpicIssues, } from '../lib/formatters.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
+import { outputResult } from '../lib/json-mode.js';
 // =============================================================================
 // epic list <project-key> [--done] [--max <n>]
 // =============================================================================
-export async function epicListCommand(projectKey, options) {
+export async function epicListCommand(projectKey, options = {}) {
     ui.startSpinner(`Fetching epics for project ${projectKey}...`);
     try {
-        const epics = await listEpics(projectKey, {
+        const epics = await getEpics(projectKey, {
             includeDone: !!options.done,
             max: options.max,
         });
         ui.stopSpinner();
-        console.log(formatEpicList(epics));
+        outputResult(epics, formatEpicList);
     }
     catch (error) {
         ui.failSpinner();
@@ -38,7 +39,7 @@ export async function epicGetCommand(epicKey) {
     try {
         const epic = await getEpic(epicKey);
         ui.stopSpinner();
-        console.log(formatEpicDetails(epic));
+        outputResult(epic, formatEpicDetails);
     }
     catch (error) {
         ui.failSpinner();
@@ -68,10 +69,13 @@ export async function epicCreateCommand(projectKey, options) {
             labels,
         });
         ui.succeedSpinner(chalk.green(`Epic created successfully: ${result.key}`));
-        console.log(chalk.gray(`\nName: ${options.name}`));
-        console.log(chalk.gray(`Summary: ${options.summary}`));
-        console.log(chalk.gray(`Project: ${projectKey}`));
-        console.log(chalk.cyan(`\nEpic Key: ${result.key}`));
+        outputResult({ key: result.key, name: options.name, summary: options.summary, project: projectKey }, (data) => {
+            let out = chalk.gray(`\nName: ${data.name}`);
+            out += `\n${chalk.gray(`Summary: ${data.summary}`)}`;
+            out += `\n${chalk.gray(`Project: ${data.project}`)}`;
+            out += `\n${chalk.cyan(`\nEpic Key: ${data.key}`)}`;
+            return out;
+        });
     }
     catch (error) {
         ui.failSpinner();
@@ -99,10 +103,14 @@ export async function epicUpdateCommand(epicKey, options) {
     try {
         await updateEpic(epicKey, { name: options.name, summary: options.summary });
         ui.succeedSpinner(chalk.green(`Epic ${epicKey} updated successfully.`));
-        if (options.name)
-            console.log(chalk.gray(`Name: ${options.name}`));
-        if (options.summary)
-            console.log(chalk.gray(`Summary: ${options.summary}`));
+        outputResult({ success: true, epicKey, name: options.name, summary: options.summary }, (data) => {
+            const lines = [];
+            if (data.name)
+                lines.push(chalk.gray(`Name: ${data.name}`));
+            if (data.summary)
+                lines.push(chalk.gray(`Summary: ${data.summary}`));
+            return lines.join('\n');
+        });
     }
     catch (error) {
         ui.failSpinner();
@@ -125,7 +133,7 @@ export async function epicIssuesCommand(epicKey, options) {
     try {
         const issues = await getEpicIssues(epicKey, { max: options.max });
         ui.stopSpinner();
-        console.log(formatEpicIssues(issues));
+        outputResult(issues, formatEpicIssues);
     }
     catch (error) {
         ui.failSpinner();
@@ -196,7 +204,7 @@ export async function epicProgressCommand(epicKey) {
     try {
         const progress = await getEpicProgress(epicKey);
         ui.stopSpinner();
-        console.log(formatEpicProgress(progress));
+        outputResult(progress, formatEpicProgress);
     }
     catch (error) {
         ui.failSpinner();

package/dist/commands/get-issue-statistics.js

@@ -2,10 +2,16 @@ import chalk from 'chalk';
 import { getIssueStatistics, validateIssuePermissions } from '../lib/jira-client.js';
 import { formatIssueStatistics } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function getIssueStatisticsCommand(taskIds, options = {}) {
     const ids = taskIds.split(',').map(id => id.trim()).filter(id => id !== '');
     if (ids.length === 0) {
-        console.error(chalk.red('Please provide at least one issue ID.'));
+        if (!isJsonMode()) {
+            console.error(chalk.red('Please provide at least one issue ID.'));
+        }
+        else {
+            outputResult({ error: true, message: 'Please provide at least one issue ID.' });
+        }
         return;
     }
     ui.startSpinner(`Fetching statistics for ${ids.length} issue(s)...`);
@@ -22,19 +28,19 @@ export async function getIssueStatisticsCommand(taskIds, options = {}) {
             if (!(error instanceof Error))
                 continue;
             const isPermissionError = error.message.includes('not allowed') || error.message.includes('restricted');
-            if (isPermissionError) {
-                console.warn(chalk.yellow(`
-Skipping ${id}: ${error.message}`));
-            }
-            else {
-                console.error(chalk.red(`
-Failed to fetch statistics for ${id}: ${error.message}`));
+            if (!isJsonMode()) {
+                if (isPermissionError) {
+                    console.warn(chalk.yellow(`\nSkipping ${id}: ${error.message}`));
+                }
+                else {
+                    console.error(chalk.red(`\nFailed to fetch statistics for ${id}: ${error.message}`));
+                }
             }
         }
     }
     if (results.length > 0) {
         ui.succeedSpinner(chalk.green('Statistics retrieved'));
-        console.log(formatIssueStatistics(results, options.fullBreakdown));
+        outputResult(results, (data) => formatIssueStatistics(data, options.fullBreakdown));
     }
     else {
         ui.failSpinner('Failed to retrieve statistics or all issues were filtered out');

package/dist/commands/get-person-worklog.js

@@ -4,6 +4,7 @@ import { searchIssuesByJql, getIssueWorklogs } from '../lib/jira-client.js';
 import { parseTimeframe, formatDateForJql } from '../lib/utils.js';
 import { formatWorklogs } from '../lib/formatters.js';
 import { CommandError } from '../lib/errors.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function getPersonWorklogCommand(person, timeframe, options) {
     ui.startSpinner(`Fetching worklogs for ${person}...`);
     try {
@@ -16,9 +17,12 @@ export async function getPersonWorklogCommand(person, timeframe, options) {
         const issues = await searchIssuesByJql(jql, 100);
         if (issues.length === 0) {
             ui.stopSpinner();
-            console.log(chalk.yellow(`
-No worklogs found for ${person} between ${startJql} and ${endJql}.
-`));
+            if (!isJsonMode()) {
+                console.log(chalk.yellow(`\nNo worklogs found for ${person} between ${startJql} and ${endJql}.\n`));
+            }
+            else {
+                outputResult([]);
+            }
             return;
         }
         const allWorklogs = [];
@@ -40,12 +44,15 @@ No worklogs found for ${person} between ${startJql} and ${endJql}.
         }
         ui.stopSpinner();
         if (allWorklogs.length === 0) {
-            console.log(chalk.yellow(`
-No worklogs found for ${person} after detailed filtering.
-`));
+            if (!isJsonMode()) {
+                console.log(chalk.yellow(`\nNo worklogs found for ${person} after detailed filtering.\n`));
+            }
+            else {
+                outputResult([]);
+            }
             return;
         }
-        console.log(formatWorklogs(allWorklogs, options.groupByIssue));
+        outputResult(allWorklogs, (data) => formatWorklogs(data, options.groupByIssue));
     }
     catch (error) {
         ui.failSpinner(`Failed to fetch worklogs: ${error.message}`);

package/dist/commands/issue.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { assignIssue, validateIssuePermissions } from '../lib/jira-client.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function issueAssignCommand(issueKey, accountId) {
     const actualAccountId = accountId === 'null' ? null : accountId;
     // Check permissions and filters
@@ -11,6 +12,7 @@ export async function issueAssignCommand(issueKey, accountId) {
     try {
         await assignIssue(issueKey, actualAccountId);
         ui.succeedSpinner(chalk.green(`Issue ${issueKey} successfully assigned to ${actualAccountId || 'Unassigned'}.`));
+        outputResult({ success: true, issueKey, assignee: actualAccountId || null }, (data) => chalk.green(`Issue ${data.issueKey} successfully assigned to ${data.assignee || 'Unassigned'}.`));
     }
     catch (error) {
         if (error instanceof CommandError) {

package/dist/commands/list-colleagues.js

@@ -4,6 +4,7 @@ import { formatUsers } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
 import { isCommandAllowed, isProjectAllowed } from '../lib/settings.js';
 import { CommandError } from '../lib/errors.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function listColleaguesCommand(projectKey) {
     if (projectKey) {
         if (!isProjectAllowed(projectKey)) {
@@ -21,10 +22,15 @@ export async function listColleaguesCommand(projectKey) {
         const users = await getUsers(projectKey);
         ui.succeedSpinner(chalk.green('Colleagues retrieved'));
         if (users.length === 0) {
-            console.log(chalk.yellow('\nNo active colleagues found.'));
+            if (!isJsonMode()) {
+                console.log(chalk.yellow('\nNo active colleagues found.'));
+            }
+            else {
+                outputResult(users);
+            }
         }
         else {
-            console.log(formatUsers(users));
+            outputResult(users, formatUsers);
         }
     }
     catch (error) {

package/dist/commands/list-issue-links.js

@@ -4,6 +4,7 @@ import { formatIssueLinks } from '../lib/formatters.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, IssueKeySchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function listIssueLinksCommand(issueKey) {
     validateOptions(IssueKeySchema, issueKey);
     ui.startSpinner(`Validating permissions for ${issueKey}...`);
@@ -12,7 +13,7 @@ export async function listIssueLinksCommand(issueKey) {
     try {
         const links = await getIssueLinks(issueKey);
         ui.succeedSpinner(chalk.green(`Issue links retrieved for ${issueKey}`));
-        console.log(formatIssueLinks(issueKey, links));
+        outputResult(links, (data) => formatIssueLinks(issueKey, data));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/list-issue-types.js

@@ -4,6 +4,7 @@ import { formatProjectIssueTypes } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
 import { isCommandAllowed, isProjectAllowed } from '../lib/settings.js';
 import { CommandError } from '../lib/errors.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function listIssueTypesCommand(projectKey) {
     // Check if project is allowed
     if (!isProjectAllowed(projectKey)) {
@@ -16,5 +17,5 @@ export async function listIssueTypesCommand(projectKey) {
     ui.startSpinner(`Fetching issue types for project ${projectKey}...`);
     const issueTypes = await getProjectIssueTypes(projectKey);
     ui.succeedSpinner(chalk.green('Issue types retrieved'));
-    console.log(formatProjectIssueTypes(projectKey, issueTypes));
+    outputResult(issueTypes, (data) => formatProjectIssueTypes(projectKey, data));
 }

package/dist/commands/list-link-types.js

@@ -3,12 +3,13 @@ import { getAvailableLinkTypes } from '../lib/jira-client.js';
 import { formatLinkTypes } from '../lib/formatters.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function listLinkTypesCommand() {
     ui.startSpinner('Fetching available link types...');
     try {
         const linkTypes = await getAvailableLinkTypes();
         ui.succeedSpinner(chalk.green('Link types retrieved'));
-        console.log(formatLinkTypes(linkTypes));
+        outputResult(linkTypes, formatLinkTypes);
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/me.js

@@ -2,9 +2,10 @@ import chalk from 'chalk';
 import { getCurrentUser } from '../lib/jira-client.js';
 import { formatUserInfo } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function meCommand() {
     ui.startSpinner('Fetching user information...');
     const user = await getCurrentUser();
     ui.succeedSpinner(chalk.green('User information retrieved'));
-    console.log(formatUserInfo(user));
+    outputResult(user, formatUserInfo);
 }

package/dist/commands/project-fields.js

@@ -3,6 +3,7 @@ import { getProjectFields } from '../lib/field-resolver.js';
 import { CommandError } from '../lib/errors.js';
 import { validateOptions, ProjectKeySchema } from '../lib/validation.js';
 import { isCommandAllowed, isProjectAllowed } from '../lib/settings.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function projectFieldsCommand(projectKey, options) {
     if (!projectKey) {
         throw new CommandError('Project key is required');
@@ -24,20 +25,28 @@ export async function projectFieldsCommand(projectKey, options) {
             fields = fields.filter(f => f.name.toLowerCase().includes(lower) || f.id.toLowerCase().includes(lower));
         }
         if (fields.length === 0) {
-            console.log(chalk.yellow(`No fields found for project ${projectKey}`));
+            if (!isJsonMode()) {
+                console.log(chalk.yellow(`No fields found for project ${projectKey}`));
+            }
+            else {
+                outputResult(fields);
+            }
             return;
         }
-        console.log(chalk.bold(`\nFields for project ${projectKey}:`));
-        console.log(chalk.gray(`${'ID'.padEnd(30)} ${'Name'.padEnd(30)} ${'Type'.padEnd(20)} Required`));
-        console.log(chalk.gray('-'.repeat(90)));
-        for (const field of fields) {
-            const required = field.required ? chalk.red('yes') : chalk.gray('no');
-            const idLabel = field.custom ? chalk.cyan(field.id.padEnd(30)) : field.id.padEnd(30);
-            const nameLabel = field.custom ? chalk.cyan(field.name.padEnd(30)) : field.name.padEnd(30);
-            const type = (field.schema?.type || 'unknown').padEnd(20);
-            console.log(`${idLabel} ${nameLabel} ${type} ${required}`);
-        }
-        console.log(chalk.gray(`\nTotal: ${fields.length} field(s)`));
+        outputResult(fields, (data) => {
+            let out = chalk.bold(`\nFields for project ${projectKey}:`);
+            out += `\n${chalk.gray(`${'ID'.padEnd(30)} ${'Name'.padEnd(30)} ${'Type'.padEnd(20)} Required`)}`;
+            out += `\n${chalk.gray('-'.repeat(90))}`;
+            for (const field of data) {
+                const required = field.required ? chalk.red('yes') : chalk.gray('no');
+                const idLabel = field.custom ? chalk.cyan(field.id.padEnd(30)) : field.id.padEnd(30);
+                const nameLabel = field.custom ? chalk.cyan(field.name.padEnd(30)) : field.name.padEnd(30);
+                const type = (field.schema?.type || 'unknown').padEnd(20);
+                out += `\n${idLabel} ${nameLabel} ${type} ${required}`;
+            }
+            out += `\n${chalk.gray(`\nTotal: ${data.length} field(s)`)}`;
+            return out;
+        });
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/project-statuses.js

@@ -4,6 +4,7 @@ import { formatProjectStatuses } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
 import { isCommandAllowed, isProjectAllowed } from '../lib/settings.js';
 import { CommandError } from '../lib/errors.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function projectStatusesCommand(projectIdOrKey) {
     // Check if project is allowed
     if (!isProjectAllowed(projectIdOrKey)) {
@@ -17,7 +18,7 @@ export async function projectStatusesCommand(projectIdOrKey) {
     try {
         const statuses = await getProjectStatuses(projectIdOrKey);
         ui.succeedSpinner(chalk.green('Project statuses retrieved'));
-        console.log(formatProjectStatuses(projectIdOrKey, statuses));
+        outputResult(statuses, (data) => formatProjectStatuses(projectIdOrKey, data));
     }
     catch (error) {
         ui.failSpinner(chalk.red('Failed to fetch project statuses'));

package/dist/commands/projects.js

@@ -3,6 +3,7 @@ import { getProjects } from '../lib/jira-client.js';
 import { formatProjects } from '../lib/formatters.js';
 import { getAllowedProjects, isProjectAllowed } from '../lib/settings.js';
 import { ui } from '../lib/ui.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function projectsCommand() {
     ui.startSpinner('Fetching projects...');
     const allProjects = await getProjects();
@@ -13,12 +14,12 @@ export async function projectsCommand() {
         ? allProjects
         : allProjects.filter(project => isProjectAllowed(project.key));
     ui.succeedSpinner(chalk.green('Projects retrieved'));
-    if (filteredProjects.length === 0) {
+    if (!isJsonMode() && filteredProjects.length === 0) {
         console.log(chalk.yellow('\nNo projects match your settings configuration.'));
         const displayKeys = allowedProjects.map(p => typeof p === 'string' ? p : p.key);
         console.log(chalk.gray('Allowed projects: ' + displayKeys.join(', ')));
     }
     else {
-        console.log(formatProjects(filteredProjects));
+        outputResult(filteredProjects, formatProjects);
     }
 }

package/dist/commands/run-jql.js

@@ -2,15 +2,18 @@ import chalk from 'chalk';
 import { searchIssuesByJql } from '../lib/jira-client.js';
 import { formatJqlResults } from '../lib/formatters.js';
 import { ui } from '../lib/ui.js';
+import { outputResult, isJsonMode } from '../lib/json-mode.js';
 export async function runJqlCommand(jqlQuery, options) {
     // Parse and validate limit parameter
     let maxResults = options.limit || 50;
     if (maxResults > 1000) {
-        console.warn(chalk.yellow('\nWarning: Limit is very high. Using 1000 as maximum.'));
+        if (!isJsonMode()) {
+            console.warn(chalk.yellow('\nWarning: Limit is very high. Using 1000 as maximum.'));
+        }
         maxResults = 1000;
     }
     ui.startSpinner('Executing JQL query...');
     const issues = await searchIssuesByJql(jqlQuery, maxResults);
     ui.succeedSpinner(chalk.green('Query executed successfully'));
-    console.log(formatJqlResults(issues));
+    outputResult(issues, formatJqlResults);
 }

package/dist/commands/settings.js

@@ -8,6 +8,7 @@ import { SettingsSchema } from '../lib/validation.js';
 import { getProjects } from '../lib/jira-client.js';
 import { CommandError } from '../lib/errors.js';
 import { validateEnvVars } from '../lib/utils.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function settingsCommand(options) {
     if (options.reset) {
         ui.startSpinner('Resetting settings to default...');
@@ -31,7 +32,7 @@ export async function settingsCommand(options) {
     }
     // Default: Show current settings
     const settings = loadSettings();
-    console.log(formatSettings(settings));
+    outputResult(settings, formatSettings);
 }
 async function validateSettingsFile(filePath) {
     ui.startSpinner(`Validating ${filePath}...`);

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

@@ -3,6 +3,7 @@ import { validateIssuePermissions } from '../lib/jira-client.js';
 import { formatTaskDetails } from '../lib/formatters.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function taskWithDetailsCommand(taskId, options = {}) {
     ui.startSpinner(`Fetching details for ${taskId}...`);
     try {
@@ -12,7 +13,7 @@ export async function taskWithDetailsCommand(taskId, options = {}) {
             historyOffset: options.historyOffset ? parseInt(options.historyOffset, 10) : undefined,
         });
         ui.succeedSpinner(chalk.green('Task details retrieved'));
-        console.log(formatTaskDetails(task));
+        outputResult(task, formatTaskDetails);
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/transition.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import { getIssueTransitions, transitionIssue, validateIssuePermissions } from '../lib/jira-client.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function transitionCommand(taskId, toStatus) {
     // Check permissions and filters
     ui.startSpinner(`Validating permissions for ${taskId}...`);
@@ -33,6 +34,7 @@ export async function transitionCommand(taskId, toStatus) {
         ui.startSpinner(`Transitioning ${taskId} to ${transition.to.name}...`);
         await transitionIssue(taskId, transition.id);
         ui.succeedSpinner(chalk.green(`Issue ${taskId} successfully transitioned to ${transition.to.name}.`));
+        outputResult({ success: true, issueKey: taskId, status: transition.to.name }, (data) => chalk.green(`Issue ${data.issueKey} successfully transitioned to ${data.status}.`));
     }
     catch (error) {
         if (error instanceof CommandError) {

package/dist/commands/update-description.js

@@ -7,6 +7,7 @@ import { processMentionsInADF } from '../lib/adf-mentions.js';
 import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, UpdateDescriptionSchema, IssueKeySchema } from '../lib/validation.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function updateDescriptionCommand(taskId, options) {
     // Validate taskId (positional)
     validateOptions(IssueKeySchema, taskId);
@@ -49,8 +50,7 @@ export async function updateDescriptionCommand(taskId, options) {
     try {
         await updateIssueDescription(taskId, adfContent);
         ui.succeedSpinner(chalk.green(`Description updated successfully for ${taskId}`));
-        console.log(chalk.gray(`
-File: ${absolutePath}`));
+        outputResult({ success: true, issueKey: taskId, file: absolutePath }, (data) => chalk.gray(`\nFile: ${data.file}`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/commands/update-issue.js

@@ -7,6 +7,7 @@ import { CommandError } from '../lib/errors.js';
 import { ui } from '../lib/ui.js';
 import { validateOptions, UpdateIssueSchema, IssueKeySchema } from '../lib/validation.js';
 import { isCommandAllowed, isProjectAllowed } from '../lib/settings.js';
+import { outputResult } from '../lib/json-mode.js';
 export async function updateIssueCommand(issueKey, options) {
     validateOptions(IssueKeySchema, issueKey);
     validateOptions(UpdateIssueSchema, options);
@@ -86,6 +87,7 @@ export async function updateIssueCommand(issueKey, options) {
     try {
         await updateIssue(issueKey, fields);
         ui.succeedSpinner(chalk.green(`Issue ${issueKey} updated successfully`));
+        outputResult({ success: true, issueKey }, (data) => chalk.green(`Issue ${data.issueKey} updated successfully`));
     }
     catch (error) {
         if (error instanceof CommandError)

package/dist/lib/jira-client.js

@@ -946,3 +946,4 @@ export async function getAvailableLinkTypes() {
         outward: t.outward,
     }));
 }
+export const getEpics = listEpics;

package/dist/lib/json-mode.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+let _jsonMode = false;
+let _compactMode = false;
+export function initJsonMode() {
+    _jsonMode = process.argv.includes('--json') || process.argv.includes('--json-compact');
+    _compactMode = process.argv.includes('--json-compact');
+}
+export function isJsonMode() {
+    return _jsonMode;
+}
+export function isCompactMode() {
+    return _compactMode;
+}
+export function outputResult(data, formatter) {
+    if (_jsonMode) {
+        const output = _compactMode
+            ? JSON.stringify(data)
+            : JSON.stringify(data, null, 2);
+        console.log(output);
+    }
+    else {
+        if (formatter) {
+            console.log(formatter(data));
+        }
+        else if (typeof data === 'object' && data !== null) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(data);
+        }
+    }
+}
+export function outputError(message, hints = [], exitCode = 1) {
+    if (_jsonMode) {
+        console.log(JSON.stringify({ error: true, message, hints, exitCode }));
+        process.exit(exitCode);
+    }
+    else {
+        console.error(chalk.red(`\n❌ Error: ${message}`));
+        hints.forEach(hint => {
+            console.error(chalk.yellow(`   Hint: ${hint}`));
+        });
+        process.exit(exitCode);
+    }
+}

package/dist/lib/ui.js

@@ -1,7 +1,11 @@
 import ora from 'ora';
+import { isJsonMode } from './json-mode.js';
 class UI {
     spinnerInstance = null;
     startSpinner(message) {
+        if (isJsonMode()) {
+            return null;
+        }
         if (this.spinnerInstance) {
             this.spinnerInstance.stop();
         }
@@ -9,24 +13,36 @@ class UI {
         return this.spinnerInstance;
     }
     stopSpinner() {
+        if (isJsonMode()) {
+            return;
+        }
         if (this.spinnerInstance) {
             this.spinnerInstance.stop();
             this.spinnerInstance = null;
         }
     }
     succeedSpinner(message) {
+        if (isJsonMode()) {
+            return;
+        }
         if (this.spinnerInstance) {
             this.spinnerInstance.succeed(message);
             this.spinnerInstance = null;
         }
     }
     failSpinner(message) {
+        if (isJsonMode()) {
+            return;
+        }
         if (this.spinnerInstance) {
             this.spinnerInstance.fail(message);
             this.spinnerInstance = null;
         }
     }
     updateSpinner(message) {
+        if (isJsonMode()) {
+            return;
+        }
         if (this.spinnerInstance) {
             this.spinnerInstance.text = message;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jira-ai",
-  "version": "0.9.96",
+  "version": "0.9.97",
   "description": "AI friendly Jira CLI to save context",
   "type": "module",
   "main": "dist/cli.js",