jira-ai 1.6.0 → 1.8.0

package/README.md

@@ -209,6 +209,46 @@ jira-ai issue comments PROJ-123 --since 2026-01-01T00:00:00Z --reverse --limit 2
 
 **Activity types:** `status_change`, `field_change`, `comment_added`, `comment_updated`, `attachment_added`, `attachment_removed`, `link_added`, `link_removed`
 
+### User Activity
+
+Retrieve a user's activity across all issues in a timeframe — comments, status changes, field changes, and more:
+
+```bash
+jira-ai user activity "Jane Smith" 7d
+```
+
+Filter by project:
+
+```bash
+jira-ai user activity "Jane Smith" 7d --project PS
+```
+
+Filter by activity type:
+
+```bash
+jira-ai user activity "Jane Smith" 7d --types comment_added,status_change
+```
+
+Group results by issue instead of a flat timeline:
+
+```bash
+jira-ai user activity "Jane Smith" 14d --project PS --group-by-issue
+```
+
+Use `--compact` to strip comment bodies for token efficiency:
+
+```bash
+jira-ai --compact user activity "Jane Smith" 30d --types comment_added
+```
+
+Set a result limit:
+
+```bash
+jira-ai user activity "Jane Smith" 7d --limit 100
+```
+
+**Permission:** `user.activity` — must be explicitly granted (not covered by `user.worklog`).
+
 ### Worklog Management
 
 Log time against issues with full CRUD support:
@@ -277,6 +317,42 @@ jira-ai issue worklog add PROJ-123 --time 2h --dry-run
 
 Duration format uses Jira-style notation: `1w` (5 working days), `1d` (8 hours), `1h`, `30m`, or combinations like `1d2h30m`.
 
+### User Worklog
+
+Retrieve worklogs for a specific user over a timeframe:
+
+```bash
+jira-ai user worklog "Jane Smith" 7d
+```
+
+Group results by issue:
+
+```bash
+jira-ai user worklog "Jane Smith" 30d --group-by-issue
+```
+
+Restrict to a specific project:
+
+```bash
+jira-ai user worklog "Jane Smith" 30d --project PS
+```
+
+### Issue Search Enhancements
+
+Search issues with JQL and filter by comment author:
+
+```bash
+jira-ai issue search 'project = PS AND updated >= -7d' --comment-author "Jane Smith"
+```
+
+Use `--comment-author` without a JQL query to find all issues commented on by a user:
+
+```bash
+jira-ai issue search --comment-author "Jane Smith" --limit 50
+```
+
+`--comment-author` can be combined with both positional JQL and `--query` (saved queries).
+
 ## Service Account Authentication
 
 Atlassian service accounts use scoped API tokens that must authenticate through the `api.atlassian.com` gateway rather than direct site URLs.
@@ -365,15 +441,134 @@ jira-ai issue search --query overdue-tasks --limit 10
 
 Saved queries are mutually exclusive with raw JQL — you cannot provide both a positional JQL argument and `--query` at the same time.
 
+## Presets
+
+Predefined configuration presets let you quickly set up permission levels without manually editing `settings.yaml`. Presets configure `allowed-commands`, `allowed-jira-projects`, and `allowed-confluence-spaces` in one step.
+
+The `--preset`, `--list-presets`, `--detect-preset`, `--apply`, `--validate`, and `--reset` flags are mutually exclusive — only one can be used at a time.
+
+### Available Presets
+
+| Preset | Description |
+| :--- | :--- |
+| `read-only` | AI can only observe. No create, update, delete, or transition operations. |
+| `standard` | AI can perform common productive actions but cannot do destructive operations (delete, sprint management). |
+| `my-tasks` | AI has full command access but is restricted to issues where the current user participated (assignee, reporter, commenter, or watcher). |
+| `yolo` | Unrestricted access. The AI can do everything. The name explicitly signals risk. |
+
+#### What each preset allows
+
+- **`read-only`** — `issue get/search/stats/comments/activity/tree/worklog.list/link.list/link.types/attach/list`, `project list/statuses/types/fields`, `user me/search/worklog/activity`, `confl get/spaces/pages/search`, `epic list/get/issues/progress`, `board list/get/config/issues`, `sprint list/get/issues/tree`
+- **`standard`** — Everything in `read-only`, plus `issue create/update/transition/comment/assign/label.add/label.remove/link.create/attach.upload/attach.download/worklog.add/worklog.update`, `confl create/comment/update`, `epic create/update/link/unlink`, `sprint update`
+- **`my-tasks`** — All commands across all domains (`issue`, `project`, `user`, `confl`, `epic`, `board`, `sprint`, `backlog`), but issue visibility is filtered to those where the user participated (see [globalParticipationFilter](#globalparticipationfilter) below)
+- **`yolo`** — All commands, all projects, all Confluence spaces. No restrictions.
+
+### Usage
+
+Apply a preset:
+
+```bash
+jira-ai settings --preset read-only
+jira-ai settings --preset standard
+jira-ai settings --preset my-tasks
+jira-ai settings --preset yolo
+```
+
+List all available presets with their full configuration details:
+
+```bash
+jira-ai settings --list-presets
+```
+
+Detect which preset (if any) your current settings match:
+
+```bash
+jira-ai settings --detect-preset
+```
+
+If your settings don't match any preset exactly, `--detect-preset` reports `custom` and shows the closest match with a diff of added/removed commands.
+
+Reset settings to defaults:
+
+```bash
+jira-ai settings --reset
+```
+
+Validate a settings file without applying it:
+
+```bash
+jira-ai settings --validate my-settings.yaml
+```
+
+Apply a settings file:
+
+```bash
+jira-ai settings --apply my-settings.yaml
+```
+
+View current settings:
+
+```bash
+jira-ai settings
+```
+
+After applying a preset, you can further customize permissions by editing `~/.jira-ai/settings.yaml`. Saved queries are preserved when switching presets.
+
+### globalParticipationFilter
+
+The `my-tasks` preset sets a `globalParticipationFilter` in `settings.yaml` that restricts which issues the AI can see and interact with. Only issues where the current user matches at least one participation criterion are accessible:
+
+```yaml
+defaults:
+  globalParticipationFilter:
+    was_assignee: true
+    was_reporter: true
+    was_commenter: true
+    is_watcher: true
+```
+
+| Field | JQL equivalent | Meaning |
+| :--- | :--- | :--- |
+| `was_assignee` | `assignee was currentUser()` | User was ever assigned to the issue |
+| `was_reporter` | `reporter = currentUser()` | User is the issue reporter |
+| `was_commenter` | `issue in issueHistory()` | User commented on the issue |
+| `is_watcher` | `issue in watchedIssues()` | User is watching the issue |
+
+The filter applies to both search queries (JQL is automatically wrapped) and direct issue access (per-issue validation). You can customize the filter after applying a preset by editing `~/.jira-ai/settings.yaml` — set individual fields to `false` to relax that criterion.
+
 ## Configuration & Restrictions
 
 Tool allows you to have very complex configutations of what Projects/Jira commands/Issue types you would have acess to thought the tool.
-Use this command to start setup: 
+
+### Quick setup with presets
+
+The fastest way to configure permissions is with a preset (see [Presets](#presets) above):
+
+```bash
+jira-ai settings --preset standard
+```
+
+### Manual setup
+
+Use this command to start setup:
 
 ```bash
 jira-ai settings --help
 ```
 
+You can also validate or apply settings from a YAML file:
+
+```bash
+jira-ai settings --validate my-settings.yaml
+jira-ai settings --apply my-settings.yaml
+```
+
+To revert to default settings:
+
+```bash
+jira-ai settings --reset
+```
+
 All avalible commands: [https://github.com/festoinc/jira-ai/blob/main/all_avaliable_commands.md](https://github.com/festoinc/jira-ai/blob/main/all_avaliable_commands.md)
 
 ## Links

package/dist/cli.js

@@ -25,6 +25,7 @@ import { sprintTreeCommand } from './commands/sprint-tree.js';
 import { uploadAttachmentCommand, listAttachmentsCommand, downloadAttachmentCommand, deleteAttachmentCommand, } from './commands/attach.js';
 import { getIssueStatisticsCommand } from './commands/get-issue-statistics.js';
 import { getPersonWorklogCommand } from './commands/get-person-worklog.js';
+import { userActivityCommand } from './commands/user-activity.js';
 import { isCommandAllowed, getAllowedCommands } from './lib/settings.js';
 import { confluenceGetPageCommand, confluenceListSpacesCommand, confluenceGetSpacePagesHierarchyCommand, confluenceAddCommentCommand, confluenceCreatePageCommand, confluenceUpdateDescriptionCommand, confluenceSearchCommand } from './commands/confluence.js';
 import { epicListCommand, epicGetCommand, epicCreateCommand, epicUpdateCommand, epicIssuesCommand, epicLinkCommand, epicUnlinkCommand, epicProgressCommand, } from './commands/epic.js';
@@ -42,7 +43,7 @@ import { checkForUpdate, formatUpdateMessage, checkForUpdateSync } from './lib/u
 import { CliError } from './types/errors.js';
 import { CommandError } from './lib/errors.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, BoardListSchema, BoardIssuesSchema, BoardRankSchema, SprintListSchema, SprintCreateSchema, SprintUpdateSchema, SprintIssuesSchema, SprintMoveSchema, BacklogMoveSchema, AttachUploadSchema, AttachDownloadSchema, } from './lib/validation.js';
+import { CreateTaskSchema, UpdateDescriptionSchema, ProjectFieldsSchema, ConfluenceAddCommentSchema, RunJqlSchema, GetPersonWorklogSchema, UserActivitySchema, GetIssueStatisticsSchema, EpicListSchema, EpicCreateSchema, EpicUpdateSchema, EpicLinkSchema, EpicMaxSchema, validateOptions, IssueKeySchema, ProjectKeySchema, TimeframeSchema, BoardListSchema, BoardIssuesSchema, BoardRankSchema, SprintListSchema, SprintCreateSchema, SprintUpdateSchema, SprintIssuesSchema, SprintMoveSchema, BacklogMoveSchema, AttachUploadSchema, AttachDownloadSchema, } from './lib/validation.js';
 import { realpathSync } from 'fs';
 // Create CLI program
 const program = new Command();
@@ -142,6 +143,7 @@ issue
     .option('-l, --limit <number>', 'Maximum number of results (default: 50)', '50')
     .option('--query <name>', 'Use a saved query by name (mutually exclusive with positional JQL)')
     .option('--list-queries', 'List all available saved queries')
+    .option('--comment-author <name>', 'Filter to issues commented on by this user (display name or account ID)')
     .action(withPermission('issue.search', runJqlCommand, {
     schema: RunJqlSchema,
     validateArgs: (args) => {
@@ -149,8 +151,9 @@ issue
         const opts = args[args.length - 2];
         const hasQuery = opts && opts.query;
         const hasListQueries = opts && opts.listQueries;
-        if (!hasQuery && !hasListQueries && (typeof jqlQuery !== 'string' || jqlQuery.trim() === '')) {
-            throw new CliError('JQL query cannot be empty. Provide a JQL query, use --query <name>, or use --list-queries.');
+        const hasCommentAuthor = opts && opts.commentAuthor;
+        if (!hasQuery && !hasListQueries && !hasCommentAuthor && (typeof jqlQuery !== 'string' || jqlQuery.trim() === '')) {
+            throw new CliError('JQL query cannot be empty. Provide a JQL query, use --query <name>, --comment-author <name>, or use --list-queries.');
         }
     }
 }));
@@ -522,12 +525,26 @@ user
     .command('worklog <person> <timeframe>')
     .description('Retrieve worklogs for a user over a timeframe (e.g., "7d", "2w").')
     .option('--group-by-issue', 'Group the output by issue')
+    .option('--project <key>', 'Filter worklogs to a specific project key')
     .action(withPermission('user.worklog', getPersonWorklogCommand, {
     schema: GetPersonWorklogSchema,
     validateArgs: (args) => {
         validateOptions(TimeframeSchema, args[1]);
     }
 }));
+user
+    .command('activity <person> <timeframe>')
+    .description('Show activity (comments, status changes, field changes) for a user over a timeframe.')
+    .option('--project <key>', 'Filter to a specific project key')
+    .option('--types <types>', 'Comma-separated activity types to include (e.g., "comment_added,status_change")')
+    .option('--limit <number>', 'Maximum number of activity entries to return')
+    .option('--group-by-issue', 'Group activities by issue')
+    .action(withPermission('user.activity', userActivityCommand, {
+    schema: UserActivitySchema,
+    validateArgs: (args) => {
+        validateOptions(TimeframeSchema, args[1]);
+    }
+}));
 // =============================================================================
 // CONFLUENCE COMMANDS
 // =============================================================================
@@ -763,12 +780,19 @@ program
     .option('--apply <path>', 'Validate and apply settings from a YAML file')
     .option('--validate <path>', 'Perform schema and deep validation of a settings YAML file')
     .option('--reset', 'Revert settings to default')
+    .option('--preset <name>', 'Apply a predefined configuration preset (read-only, standard, my-tasks, yolo)')
+    .option('--list-presets', 'List all available predefined presets with their details')
+    .option('--detect-preset', 'Detect which preset (if any) matches current settings')
     .addHelpText('after', `
 Examples:
   $ jira-ai settings
   $ jira-ai settings --validate my-settings.yaml
   $ jira-ai settings --apply my-settings.yaml
   $ jira-ai settings --reset
+  $ jira-ai settings --preset read-only
+  $ jira-ai settings --preset standard
+  $ jira-ai settings --list-presets
+  $ jira-ai settings --detect-preset
 
 Settings File Structure:
   defaults:
@@ -782,7 +806,7 @@ Settings File Structure:
 Command Groups (use in allowed-commands):
   issue       - get, create, search, transition, update, comment, stats, assign, label
   project     - list, statuses, types
-  user        - me, search, worklog
+  user        - me, search, worklog, activity
   epic        - list, get, create, update, issues, link, unlink, progress
   confl       - get, spaces, pages, create, comment, update
   board       - list, get, config, issues, rank

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

@@ -1,4 +1,4 @@
-import { searchIssuesByJql, getIssueWorklogs } from '../lib/jira-client.js';
+import { searchIssuesByJql, getIssueWorklogs, resolveUserByName } from '../lib/jira-client.js';
 import { parseTimeframe, formatDateForJql } from '../lib/utils.js';
 import { CommandError } from '../lib/errors.js';
 import { outputResult } from '../lib/json-mode.js';
@@ -7,9 +7,13 @@ export async function getPersonWorklogCommand(person, timeframe, options) {
         const { startDate, endDate } = parseTimeframe(timeframe);
         const startJql = formatDateForJql(startDate);
         const endJql = formatDateForJql(endDate);
+        // Resolve person to accountId for consistent JQL and in-memory filtering
+        const resolved = await resolveUserByName(person);
+        const worklogAuthor = resolved ?? person;
         // 1. Search for issues where the person has tracked time in the timeframe
         // We use a broader search first to find relevant issues
-        const jql = `worklogAuthor = "${person}" AND worklogDate >= "${startJql}" AND worklogDate <= "${endJql}"`;
+        const projectClause = options.project ? ` AND project = "${options.project}"` : '';
+        const jql = `worklogAuthor = "${worklogAuthor}" AND worklogDate >= "${startJql}" AND worklogDate <= "${endJql}"${projectClause}`;
         const issues = await searchIssuesByJql(jql, 100);
         if (issues.length === 0) {
             outputResult([]);
@@ -20,7 +24,7 @@ export async function getPersonWorklogCommand(person, timeframe, options) {
         for (const issue of issues) {
             const worklogs = await getIssueWorklogs(issue.key);
             const filteredWorklogs = worklogs.filter(w => {
-                const matchesPerson = w.author.accountId === person || w.author.emailAddress === person;
+                const matchesPerson = w.author.accountId === worklogAuthor || w.author.emailAddress === worklogAuthor;
                 const worklogDate = new Date(w.started);
                 const matchesDate = worklogDate >= startDate && worklogDate <= endDate;
                 return matchesPerson && matchesDate;

package/dist/commands/run-jql.js

@@ -1,4 +1,4 @@
-import { searchIssuesByJql } from '../lib/jira-client.js';
+import { searchIssuesByJql, resolveUserByName } from '../lib/jira-client.js';
 import { outputResult } from '../lib/json-mode.js';
 import { getSavedQuery, listSavedQueries } from '../lib/settings.js';
 import { CliError } from '../types/errors.js';
@@ -24,8 +24,21 @@ export async function runJqlCommand(jqlQuery, options) {
         resolvedJql = savedJql;
     }
     else {
+        if (!jqlQuery || jqlQuery.trim() === '') {
+            throw new CliError('A JQL query is required. Provide a JQL string or use --query <name>.');
+        }
         resolvedJql = jqlQuery;
     }
+    // Append commentAuthor filter if provided (not mutually exclusive with other options)
+    if (options.commentAuthor) {
+        const accountId = (await resolveUserByName(options.commentAuthor)) ?? options.commentAuthor;
+        if (resolvedJql && resolvedJql.trim() !== '') {
+            resolvedJql = `(${resolvedJql}) AND commentAuthor = "${accountId}"`;
+        }
+        else {
+            resolvedJql = `commentAuthor = "${accountId}"`;
+        }
+    }
     let maxResults = options.limit || 50;
     if (maxResults > 1000) {
         maxResults = 1000;

package/dist/commands/settings.js

@@ -1,12 +1,40 @@
 import fs from 'fs';
 import yaml from 'js-yaml';
-import { loadSettings, saveSettings, DEFAULT_SETTINGS, migrateSettings } from '../lib/settings.js';
+import { loadSettings, saveSettings, DEFAULT_SETTINGS, migrateSettings, __resetCache__, } from '../lib/settings.js';
 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';
+import { getPreset, listPresets, detectPreset } from '../lib/presets.js';
 export async function settingsCommand(options) {
+    const presetFlags = [options.preset, options.listPresets, options.detectPreset].filter(Boolean).length;
+    const exclusiveFlags = presetFlags + (options.reset ? 1 : 0) + (options.apply ? 1 : 0) + (options.validate ? 1 : 0);
+    if (exclusiveFlags > 1) {
+        throw new CommandError('--preset, --list-presets, --detect-preset, --reset, --apply, and --validate are mutually exclusive');
+    }
+    if (options.listPresets) {
+        outputResult({ presets: listPresets() });
+        return;
+    }
+    if (options.detectPreset) {
+        const settings = loadSettings();
+        const defaults = settings.defaults || DEFAULT_SETTINGS.defaults;
+        outputResult(detectPreset(defaults));
+        return;
+    }
+    if (options.preset) {
+        const preset = getPreset(options.preset);
+        __resetCache__();
+        const current = loadSettings();
+        const newSettings = {
+            defaults: { ...preset.defaults, ...(preset.globalParticipationFilter ? { globalParticipationFilter: preset.globalParticipationFilter } : {}) },
+            savedQueries: current.savedQueries,
+        };
+        saveSettings(newSettings);
+        outputResult({ success: true, preset: options.preset, message: `Preset applied. Edit ~/.jira-ai/settings.yaml to customize.` });
+        return;
+    }
     if (options.reset) {
         try {
             saveSettings(DEFAULT_SETTINGS);

package/dist/commands/user-activity.js

@@ -0,0 +1,67 @@
+import { searchIssuesByJql, resolveUserByName, buildUserActivityJql, getUserActivity, } from '../lib/jira-client.js';
+import { parseTimeframe, formatDateForJql } from '../lib/utils.js';
+import { CommandError } from '../lib/errors.js';
+import { outputResult } from '../lib/json-mode.js';
+const VALID_ACTIVITY_TYPES = [
+    'status_change',
+    'field_change',
+    'link_added',
+    'link_removed',
+    'attachment_added',
+    'attachment_removed',
+    'comment_added',
+    'comment_updated',
+];
+export async function userActivityCommand(person, timeframe, options) {
+    const { project, types, limit, groupByIssue } = options;
+    if (limit !== undefined && limit <= 0) {
+        throw new CommandError('--limit must be greater than 0');
+    }
+    if (types) {
+        const requestedTypes = types.split(',').map((t) => t.trim());
+        const invalid = requestedTypes.filter((t) => !VALID_ACTIVITY_TYPES.includes(t));
+        if (invalid.length > 0) {
+            throw new CommandError(`Invalid --types value(s): ${invalid.join(', ')}. Valid types: ${VALID_ACTIVITY_TYPES.join(', ')}`);
+        }
+    }
+    const { startDate, endDate } = parseTimeframe(timeframe);
+    const startJql = formatDateForJql(startDate);
+    const endJql = formatDateForJql(endDate);
+    // Resolve person to accountId, fall back to raw string
+    const accountId = (await resolveUserByName(person)) ?? person;
+    const jql = buildUserActivityJql(accountId, startJql, endJql, project);
+    const issues = await searchIssuesByJql(jql, 100);
+    if (issues.length === 0) {
+        outputResult({ activities: [], skipped: 0 });
+        return;
+    }
+    const feedOptions = {
+        since: startDate.toISOString(),
+        author: accountId,
+        ...(types ? { types } : {}),
+        ...(limit ? { limit: limit * 2 } : {}), // fetch extra to allow for sorting + slicing
+    };
+    const { entries, skipped } = await getUserActivity(accountId, issues, feedOptions);
+    // Sort by timestamp descending
+    entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    // Apply limit (applies to activities, not issues)
+    const limited = limit ? entries.slice(0, limit) : entries;
+    if (groupByIssue) {
+        const grouped = new Map();
+        for (const entry of limited) {
+            if (!grouped.has(entry.issueKey)) {
+                grouped.set(entry.issueKey, {
+                    issueKey: entry.issueKey,
+                    summary: entry.issueSummary,
+                    activities: [],
+                });
+            }
+            const { issueKey: _k, issueSummary: _s, ...rest } = entry;
+            grouped.get(entry.issueKey).activities.push(rest);
+        }
+        outputResult({ issues: Array.from(grouped.values()), skipped });
+    }
+    else {
+        outputResult({ activities: limited, skipped });
+    }
+}

package/dist/lib/jira-client.js

@@ -1366,3 +1366,42 @@ export async function deleteWorklogEntry(issueIdOrKey, worklogId, options = {})
         params.increaseBy = increaseBy;
     await client.issueWorklogs.deleteWorklog(params);
 }
+/**
+ * Build JQL to find issues where the given user has had activity in the timeframe.
+ * Uses commentAuthor for comment-based search (valid JQL field).
+ */
+export function buildUserActivityJql(accountId, startJql, endJql, projectKey) {
+    const projectClause = projectKey ? ` AND project = "${projectKey}"` : '';
+    return (`(` +
+        `worklogAuthor = "${accountId}" AND worklogDate >= "${startJql}" AND worklogDate <= "${endJql}"` +
+        ` OR commentAuthor = "${accountId}" AND updated >= "${startJql}" AND updated <= "${endJql}"` +
+        ` OR assignee = "${accountId}" AND updated >= "${startJql}" AND updated <= "${endJql}"` +
+        `)` +
+        projectClause);
+}
+/**
+ * Fetch activity for a user across issues, using batch parallelism of 5 concurrent requests.
+ * Skips issues that fail (partial failure tolerance).
+ */
+export async function getUserActivity(accountId, issues, feedOptions) {
+    const BATCH_SIZE = 5;
+    let skipped = 0;
+    const allEntries = [];
+    for (let i = 0; i < issues.length; i += BATCH_SIZE) {
+        const batch = issues.slice(i, i + BATCH_SIZE);
+        const results = await Promise.allSettled(batch.map((issue) => getIssueActivityFeed(issue.key, feedOptions)));
+        for (let j = 0; j < results.length; j++) {
+            const result = results[j];
+            const issue = batch[j];
+            if (result.status === 'fulfilled') {
+                for (const entry of result.value.activities) {
+                    allEntries.push({ ...entry, issueKey: issue.key, issueSummary: issue.summary });
+                }
+            }
+            else {
+                skipped++;
+            }
+        }
+    }
+    return { entries: allEntries, skipped };
+}

package/dist/lib/presets.js

@@ -0,0 +1,215 @@
+export const PRESETS = {
+    'read-only': {
+        description: 'AI can only observe. No create, update, delete, or transition operations.',
+        defaults: {
+            'allowed-jira-projects': ['all'],
+            'allowed-commands': [
+                'issue.get',
+                'issue.search',
+                'issue.stats',
+                'issue.comments',
+                'issue.activity',
+                'issue.tree',
+                'issue.worklog.list',
+                'issue.link.list',
+                'issue.link.types',
+                'issue.attach.list',
+                'project.list',
+                'project.statuses',
+                'project.types',
+                'project.fields',
+                'user.me',
+                'user.search',
+                'user.worklog',
+                'user.activity',
+                'confl.get',
+                'confl.spaces',
+                'confl.pages',
+                'confl.search',
+                'epic.list',
+                'epic.get',
+                'epic.issues',
+                'epic.progress',
+                'board.list',
+                'board.get',
+                'board.config',
+                'board.issues',
+                'sprint.list',
+                'sprint.get',
+                'sprint.issues',
+                'sprint.tree',
+            ],
+            'allowed-confluence-spaces': ['all'],
+        },
+    },
+    'standard': {
+        description: 'AI can perform common productive actions but cannot do destructive operations.',
+        defaults: {
+            'allowed-jira-projects': ['all'],
+            'allowed-commands': [
+                'issue.get',
+                'issue.create',
+                'issue.search',
+                'issue.transition',
+                'issue.update',
+                'issue.comment',
+                'issue.stats',
+                'issue.assign',
+                'issue.label.add',
+                'issue.label.remove',
+                'issue.link.list',
+                'issue.link.create',
+                'issue.link.types',
+                'issue.attach.upload',
+                'issue.attach.list',
+                'issue.attach.download',
+                'issue.comments',
+                'issue.activity',
+                'issue.tree',
+                'issue.worklog.list',
+                'issue.worklog.add',
+                'issue.worklog.update',
+                'project.list',
+                'project.statuses',
+                'project.types',
+                'project.fields',
+                'user.me',
+                'user.search',
+                'user.worklog',
+                'user.activity',
+                'confl.get',
+                'confl.spaces',
+                'confl.pages',
+                'confl.create',
+                'confl.comment',
+                'confl.update',
+                'confl.search',
+                'epic.list',
+                'epic.get',
+                'epic.create',
+                'epic.update',
+                'epic.issues',
+                'epic.link',
+                'epic.unlink',
+                'epic.progress',
+                'board.list',
+                'board.get',
+                'board.config',
+                'board.issues',
+                'sprint.list',
+                'sprint.get',
+                'sprint.issues',
+                'sprint.tree',
+                'sprint.update',
+            ],
+            'allowed-confluence-spaces': ['all'],
+        },
+    },
+    'my-tasks': {
+        description: 'AI has full command access but restricted to issues where the current user participated.',
+        defaults: {
+            'allowed-jira-projects': ['all'],
+            'allowed-commands': [
+                'issue',
+                'project',
+                'user',
+                'confl',
+                'epic',
+                'board',
+                'sprint',
+                'backlog',
+            ],
+            'allowed-confluence-spaces': ['all'],
+        },
+        globalParticipationFilter: {
+            was_assignee: true,
+            was_reporter: true,
+            was_commenter: true,
+            is_watcher: true,
+        },
+    },
+    'yolo': {
+        description: 'Unrestricted access. The AI can do everything. The name explicitly signals risk.',
+        defaults: {
+            'allowed-jira-projects': ['all'],
+            'allowed-commands': ['all'],
+            'allowed-confluence-spaces': ['all'],
+        },
+    },
+};
+export function getPreset(name) {
+    const preset = PRESETS[name];
+    if (!preset) {
+        const available = Object.keys(PRESETS).join(', ');
+        throw new Error(`Unknown preset "${name}". Available presets: ${available}`);
+    }
+    return preset;
+}
+export function listPresets() {
+    const result = {};
+    for (const [name, preset] of Object.entries(PRESETS)) {
+        result[name] = {
+            description: preset.description,
+            'allowed-commands': preset.defaults['allowed-commands'],
+            'allowed-jira-projects': preset.defaults['allowed-jira-projects'],
+            'allowed-confluence-spaces': preset.defaults['allowed-confluence-spaces'],
+            ...(preset.globalParticipationFilter !== undefined && { globalParticipationFilter: preset.globalParticipationFilter }),
+        };
+    }
+    return result;
+}
+export function detectPreset(settings) {
+    for (const [name, preset] of Object.entries(PRESETS)) {
+        if (settingsMatchPreset(settings, preset.defaults, preset.globalParticipationFilter)) {
+            return {
+                current: name,
+                description: `Your settings match the '${name}' preset.`,
+            };
+        }
+    }
+    // Find closest match
+    let closestMatch;
+    let minDiff = Infinity;
+    for (const [name, preset] of Object.entries(PRESETS)) {
+        const currentCmds = new Set(settings['allowed-commands']);
+        const presetCmds = new Set(preset.defaults['allowed-commands']);
+        const added = [...currentCmds].filter(c => !presetCmds.has(c));
+        const removed = [...presetCmds].filter(c => !currentCmds.has(c));
+        const diff = added.length + removed.length;
+        if (diff < minDiff) {
+            minDiff = diff;
+            closestMatch = name;
+        }
+    }
+    const closestPreset = closestMatch ? PRESETS[closestMatch] : undefined;
+    const currentCmds = new Set(settings['allowed-commands']);
+    const presetCmds = closestPreset ? new Set(closestPreset.defaults['allowed-commands']) : new Set();
+    const addedCommands = [...currentCmds].filter(c => !presetCmds.has(c));
+    const removedCommands = [...presetCmds].filter(c => !currentCmds.has(c));
+    return {
+        current: 'custom',
+        description: 'Your settings do not match any predefined preset.',
+        closestMatch,
+        differences: {
+            addedCommands,
+            removedCommands,
+        },
+    };
+}
+function settingsMatchPreset(settings, presetDefaults, presetGlobalFilter) {
+    const settingsCmds = [...settings['allowed-commands']].sort();
+    const presetCmds = [...presetDefaults['allowed-commands']].sort();
+    if (JSON.stringify(settingsCmds) !== JSON.stringify(presetCmds))
+        return false;
+    const settingsProjects = [...settings['allowed-jira-projects']].map(p => typeof p === 'string' ? p : JSON.stringify(p)).sort();
+    const presetProjects = [...presetDefaults['allowed-jira-projects']].map(p => typeof p === 'string' ? p : JSON.stringify(p)).sort();
+    if (JSON.stringify(settingsProjects) !== JSON.stringify(presetProjects))
+        return false;
+    const settingsSpaces = [...settings['allowed-confluence-spaces']].sort();
+    const presetSpaces = [...presetDefaults['allowed-confluence-spaces']].sort();
+    if (JSON.stringify(settingsSpaces) !== JSON.stringify(presetSpaces))
+        return false;
+    if (JSON.stringify(settings.globalParticipationFilter ?? null) !== JSON.stringify(presetGlobalFilter ?? null))
+        return false;
+    return true;
+}

package/dist/lib/settings.js

@@ -249,12 +249,41 @@ export function getAllowedConfluenceSpaces() {
     const settings = getEffectiveSettings();
     return settings ? settings['allowed-confluence-spaces'] : ['all'];
 }
+function buildParticipationJql(filter) {
+    const parts = [];
+    if (filter.was_assignee)
+        parts.push('assignee was currentUser()');
+    if (filter.was_reporter)
+        parts.push('reporter = currentUser()');
+    if (filter.was_commenter)
+        parts.push('issue in issueHistory()');
+    if (filter.is_watcher)
+        parts.push('issue in watchedIssues()');
+    return parts.join(' OR ');
+}
 export function applyGlobalFilters(jql) {
     const settings = getEffectiveSettings();
     if (!settings)
         return jql;
     const allAllowed = settings['allowed-jira-projects'].some(p => p === 'all');
     if (allAllowed) {
+        // When globalParticipationFilter is set, inject participation-based JQL so
+        // issue.search is restricted to issues the user participated in (not just individual
+        // issue actions which validateIssueAgainstFilters already gates).
+        if (settings.globalParticipationFilter) {
+            const participationJql = buildParticipationJql(settings.globalParticipationFilter);
+            if (participationJql) {
+                let filterPart = jql;
+                let orderByPart = '';
+                const orderByMatch = jql.match(/(.*)\bORDER BY\b(.*)/i);
+                if (orderByMatch) {
+                    filterPart = orderByMatch[1].trim();
+                    orderByPart = ` ORDER BY ${orderByMatch[2].trim()}`;
+                }
+                const filterJql = filterPart.trim() ? ` AND (${filterPart})` : '';
+                return `(${participationJql})${filterJql}${orderByPart}`;
+            }
+        }
         return jql;
     }
     // Handle ORDER BY
@@ -297,8 +326,23 @@ export function validateIssueAgainstFilters(issue, currentUserId) {
     if (!project) {
         return false;
     }
-    if (typeof project === 'string')
+    if (typeof project === 'string') {
+        // Apply global participation filter when project is 'all' and globalParticipationFilter is set
+        if (project === 'all' && settings.globalParticipationFilter) {
+            const participated = settings.globalParticipationFilter;
+            let hasParticipated = false;
+            if (participated.was_assignee && issue.assignee?.accountId === currentUserId)
+                hasParticipated = true;
+            if (participated.was_reporter && issue.reporter?.accountId === currentUserId)
+                hasParticipated = true;
+            if (participated.was_commenter && issue.comments?.some((c) => c.author?.accountId === currentUserId))
+                hasParticipated = true;
+            if (participated.is_watcher && issue.watchers?.includes('CURRENT_USER'))
+                hasParticipated = true;
+            return hasParticipated;
+        }
         return true;
+    }
     if (project.filters?.participated) {
         const { participated } = project.filters;
         let hasParticipated = false;

package/dist/lib/validation.js

@@ -115,10 +115,18 @@ export const RunJqlSchema = z.object({
     limit: NumericStringSchema.optional(),
     query: z.string().optional(),
     listQueries: z.boolean().optional(),
+    commentAuthor: z.string().optional(),
 });
 export const TimeframeSchema = z.string().regex(/^\d+d$/, 'Timeframe must be in format like "7d" or "30d"');
 export const GetPersonWorklogSchema = z.object({
     groupByIssue: z.boolean().optional(),
+    project: z.string().optional(),
+});
+export const UserActivitySchema = z.object({
+    project: z.string().optional(),
+    types: z.string().optional(),
+    limit: NumericStringSchema.optional(),
+    groupByIssue: z.boolean().optional(),
 });
 export const GetIssueStatisticsSchema = z.object({
     fullBreakdown: z.boolean().optional(),
@@ -158,6 +166,12 @@ export const OrganizationSettingsSchema = z.object({
     'allowed-jira-projects': z.array(ProjectSettingSchema).nullish().transform(val => val || ['all']),
     'allowed-commands': z.array(z.string()).nullish().transform(val => val || DEFAULT_ALLOWED_COMMANDS),
     'allowed-confluence-spaces': z.array(z.string()).nullish().transform(val => val || ['all']),
+    globalParticipationFilter: z.object({
+        was_assignee: z.boolean().optional(),
+        was_reporter: z.boolean().optional(),
+        was_commenter: z.boolean().optional(),
+        is_watcher: z.boolean().optional(),
+    }).optional(),
 });
 export const SavedQueryNameSchema = z.string().regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/, 'Query name must be lowercase alphanumeric with hyphens (e.g., "my-query"), cannot start or end with a hyphen');
 export const SettingsSchema = z.object({

package/package.json

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