### Display JiraTUI Help Information

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Displays the help message for the jiratui CLI tool, showing available commands and options. This command is used after installation to verify it works.

```shell
jiratui --help
```

--------------------------------

### JiraTUI CLI Command Structure

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Illustrates the command-line interface structure for JiraTUI, including general options, available commands like 'comments', 'config', 'issues', 'ui', 'users', 'version', and 'themes'.

```shell
Usage: jiratui [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  comments  Use it to add, list or delete comments associated to work items.
  config    Shows the location of the configuration file.
  issues    Use it to search, update or delete work items.
  ui        Launches the Jira TUI application.
  users     Use it to search users and user groups.
  version   Shows the version of the tool.
  themes    List the available built-in themes.
```

--------------------------------

### Install JiraTUI with pip

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Installs the jiratui application using pip, the standard Python package installer. Ensure you have Python and pip installed.

```shell
pip install jiratui
```

--------------------------------

### Install JiraTUI with uv

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Installs the jiratui application using the uv package manager. This is the recommended installation method.

```shell
uv tool install jiratui
```

--------------------------------

### Install JiraTUI with Homebrew

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Installs the jiratui application using the Homebrew package manager. This is suitable for macOS and Linux users who use Homebrew.

```shell
brew install jiratui
```

--------------------------------

### JQL Query Examples for Assignee

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Provides examples of JQL queries to find work items assigned to a specific user, demonstrating search by both display name and email address. These queries can be used directly or saved as pre-defined expressions.

```python
assignee = "John Smith"
```

```python
assignee = "john@smith.com"
```

--------------------------------

### Install JiraTUI with pipx

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Installs the jiratui application in an isolated Python environment using pipx. This is useful for managing CLI tools.

```shell
pipx install jiratui
```

--------------------------------

### Install JiraTUI-git on Arch Linux (AUR)

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/install/index.md

Installs the jiratui-git package from the Arch User Repository (AUR) using the yay AUR helper. This is specific to Arch Linux-based systems.

```shell
yay -S jiratui-git
```

--------------------------------

### Launch JiraTUI UI Command

Source: https://github.com/whyisdifficult/jiratui/blob/main/jtsite/getting-started.html

Execute this command in your terminal to start the JiraTUI user interface after completing the configuration.

```bash
jiratui ui
```

--------------------------------

### Trigger JiraTUI Search on UI Startup

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Configures the JiraTUI application to automatically perform a search when the UI starts. This is achieved by using the --search-on-startup flag.

```shell
jiratui ui --search-on-startup
```

--------------------------------

### Launch JiraTUI UI with Startup Options

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Launches the JiraTUI UI and allows customization of startup behavior using optional arguments. These arguments control project filtering, work item selection, assignee pre-selection, JQL expression usage, theme application, and search/focus behavior on startup.

```shell
jiratui ui --project-key TEXT
jiratui ui --work-item-key TEXT
jiratui ui --assignee-account-id TEXT
jiratui ui --jql-expression-id INTEGER
jiratui ui --theme TEXT
jiratui ui --search-on-startup
jiratui ui --focus-item-on-startup INTEGER
```

--------------------------------

### Standard Full-text Search Query Example

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Demonstrates the structure of a standard full-text search query in JiraTUI, which searches within the 'summary' and 'description' fields of items. This query type is suitable for basic keyword searches.

```jql
summary ~ "search term" OR description ~ "search term"
```

--------------------------------

### Command Line Tool Usage

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Common CLI commands for JiraTUI, including version checking, configuration viewing, theme management, shell completion generation, and a workflow example for searching, updating, and commenting on issues.

```APIDOC
## Command Line Tool Usage

### Description
Provides common command-line interface (CLI) commands for interacting with JiraTUI, covering utility functions and a practical workflow for issue management.

### Method
Command-line execution.

### Endpoints
N/A (CLI commands, not REST endpoints)

### Commands
#### Utility Commands
- `jiratui version`: Displays the current installed version of JiraTUI.
- `jiratui config`: Shows the location of the JiraTUI configuration file.
- `jiratui themes`: Lists available themes for the terminal interface.
- `jiratui completions [bash|zsh|fish] [> file]`: Generates shell completion scripts for bash, zsh, or fish. Output can be redirected to a file for integration with your shell's configuration.

#### Workflow Example: Search, Update, Comment
This example demonstrates a common sequence of operations:

**Step 1: Search for issues**
```bash
jiratui issues search --project-key SCRUM --assignee-account-id 5d123abc456def789
```
- Searches for issues within the 'SCRUM' project assigned to a specific account ID.

**Step 2: View metadata for an issue**
```bash
jiratui issues update SCRUM-42 --meta
```
- Retrieves and displays detailed metadata for the issue 'SCRUM-42'.

**Step 3: Update the issue**
```bash
jiratui issues update SCRUM-42 \
  --summary "Implement user authentication" \
  --status-id 31 \
  --priority-id 1
```
- Updates the summary, status, and priority of issue 'SCRUM-42'. Note: `--status-id` and `--priority-id` require knowing the specific IDs within your Jira instance.

**Step 4: Add a comment**
```bash
jiratui comments add SCRUM-42 "Implementation completed and tested"
```
- Adds a comment to issue 'SCRUM-42'.

### Parameters
CLI commands accept various flags and arguments. Common ones include:
- `--project-key` (str): The Jira project key.
- `--assignee-account-id` (str): The Jira account ID of the assignee.
- `--meta`: Flag to display issue metadata.
- `--summary` (str): New summary for an issue.
- `--status-id` (str): The ID of the target status.
- `--priority-id` (str): The ID of the target priority.

### Request Example
See 'Workflow Example' above for command-line examples.

### Response
CLI commands typically output results to standard output (stdout) or indicate success/failure. Specific outputs depend on the command executed (e.g., issue details, configuration paths, completion scripts).

```

--------------------------------

### Configuration Setup for JiraTUI

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Sets up the YAML configuration file for JiraTUI, including essential API credentials, base URLs, account IDs, and optional settings for JQL expressions, SSL, and Git integration. Ensure sensitive information like API tokens are kept secure.

```yaml
# ~/.config/jiratui/config.yaml
jira_api_username: 'bart@simpson.com'
jira_api_token: 'your-personal-access-token'
jira_api_base_url: 'https://your-instance.atlassian.net'
jira_base_url: 'https://your-instance.atlassian.net'
jira_account_id: '5d123abc456def789'
jira_api_version: 3
cloud: true
search_results_per_page: 50
show_issue_web_links: true
default_project_key_or_id: 'MYPROJECT'

# Optional: Pre-defined JQL expressions
pre_defined_jql_expressions:
  1:
    label: "Work in current sprint"
    expression: 'sprint in openSprints()'
  2:
    label: "My open issues"
    expression: 'assignee = currentUser() AND status != Done'
jql_expression_id_for_work_items_search: 1

# Optional: SSL configuration
ssl:
  verify_ssl: true
  ca_bundle: '/path/to/ca-bundle.crt'
  certificate_file: '/path/to/client-cert.pem'
  key_file: '/path/to/client-key.pem'

# Optional: Git repositories for branch creation
git_repositories:
  1:
    name: 'Main Application'
    path: '/path/to/repo/.git'

```

--------------------------------

### JiraTUI CLI: Workflow Example - Search, Update, Comment

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

This demonstrates a typical workflow using the JiraTUI CLI: searching for issues based on project and assignee, viewing an issue's metadata, updating its summary, status, and priority, and finally adding a comment. This showcases the sequential use of different JiraTUI commands to manage an issue.

```bash
# Complete workflow example: Search, update, comment
# Step 1: Search for issues
jiratui issues search --project-key SCRUM --assignee-account-id 5d123abc456def789

# Step 2: View metadata for an issue
jiratui issues update SCRUM-42 --meta

# Step 3: Update the issue
jiratui issues update SCRUM-42 \
  --summary "Implement user authentication" \
  --status-id 31 \
  --priority-id 1

# Step 4: Add a comment
jiratui comments add SCRUM-42 "Implementation completed and tested"

```

--------------------------------

### Advanced Full-text Search Query Example

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Illustrates an advanced full-text search query in JiraTUI, which broadens the search to include any text-based field, including comments. This is useful for more comprehensive searches across various item attributes.

```jql
text ~ "search term"
```

--------------------------------

### Launch JiraTUI UI

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Launches the JiraTUI application's user interface. It can be run with default settings or by specifying a custom configuration file using the JIRA_TUI_CONFIG_FILE environment variable.

```shell
jiratui ui
```

```shell
JIRA_TUI_CONFIG_FILE=my-file.yaml jiratui ui
```

--------------------------------

### Search Jira Issues with jiratui CLI

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

This command allows users to search for Jira work items based on various criteria such as project key, issue key, assignee, creation date, and limit. It provides a tabular output of the found issues. Dependencies include the jiratui CLI installation.

```shell
jiratui issues search --help
```

```shell
jiratui issues search --project-key SCRUM
```

```shell
jiratui issues search --key SCRUM-1
```

```shell
jiratui issues search -p SCRUM -l 5 --created-from 2023-01-01
```

--------------------------------

### Advanced Configuration - Data Center/On-Premises

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Connect to Jira Data Center (on-premises) installations using the `JiraDataCenterAPI` class, ensuring correct configuration for non-cloud environments.

```APIDOC
## Advanced Configuration - Data Center/On-Premises

### Description
This section details how to configure and use the `JiraDataCenterAPI` for connecting to Jira Data Center or other on-premises Jira instances. It highlights the `cloud=False` setting as crucial for proper connection.

### Method
Python class instantiation and API calls.

### Endpoint
N/A (Configuration and API client setup)

### Parameters
#### `ApplicationConfiguration` for On-Premises
- **jira_api_username** (str) - Required - Username for authentication.
- **jira_api_token** (str) - Required - API token or password for authentication.
- **jira_api_base_url** (str) - Required - The base URL of your on-premises Jira instance (e.g., 'https://jira.company.com').
- **cloud** (bool) - Required - Set to `False` to indicate a non-cloud (on-premises) Jira instance.

#### `JiraDataCenterAPI` Constructor
- **base_url** (str) - Required - Same as `jira_api_base_url` from configuration.
- **api_username** (str) - Required - Same as `jira_api_username` from configuration.
- **api_token** (str) - Required - Same as `jira_api_token` from configuration.
- **configuration** (ApplicationConfiguration) - Required - The configured `ApplicationConfiguration` object with `cloud=False`.

### Request Example
```python
from jiratui.api.api import JiraDataCenterAPI
from jiratui.config import ApplicationConfiguration

config = ApplicationConfiguration(
    jira_api_username='admin',
    jira_api_token='your-token',
    jira_api_base_url='https://jira.company.com',
    cloud=False  # Important: set to False for on-premises
)

api = JiraDataCenterAPI(
    base_url=config.jira_api_base_url,
    api_username=config.jira_api_username,
    api_token=config.jira_api_token.get_secret_value(),
    configuration=config
)

# Subsequent API calls use the 'api' object
# Example: issues = await api.get_issues(project='PROJ')
```

### Response
N/A (This section describes setup, not direct responses.)

### Notes
- API usage is generally similar to `JiraAPI`.
- Some features available in Jira Cloud might not be supported or behave differently in Data Center (e.g., approximate count).

```

--------------------------------

### Jira API Credentials Configuration (YAML)

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/configuration/index.md

Provides an example of how to configure Jira API credentials in the `config.yaml` file. This includes the username, API token (or Personal Access Token), and the base URL for the Jira instance.

```yaml
jira_api_username: 'bart@simpson.com'
jira_api_token: '12345'
jira_api_base_url: 'https://<your-jira-instance-hostname>.atlassian.net'
```

--------------------------------

### Show Jira Issue Metadata with jiratui CLI

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

This command retrieves metadata for a specific Jira work item, including valid work types, priority IDs, and status transitions. This information is crucial for updating work items, such as changing their status. Input is the issue key. Dependencies include the jiratui CLI installation.

```shell
jiratui issues metadata SCRUM-1
```

--------------------------------

### Check JiraTUI Version

Source: https://github.com/whyisdifficult/jiratui/blob/main/README.md

Checks and displays the currently installed version of the JiraTUI tool.

```shell
jiratui version
1.0.0
```

--------------------------------

### Search Jira Users

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Searches for Jira users by providing a partial name or email address. The command returns a table with user account details.

```shell
jiratui users search maggie
```

--------------------------------

### JQL Examples for Assignee Search

Source: https://github.com/whyisdifficult/jiratui/blob/main/src/jiratui/utils/in_app_help.md

Demonstrates how to search for work items assigned to a specific user by their name or email address using JQL queries. This functionality is part of JiraTUI's JQL expression search.

```python
assignee = "John Smith"

```

```python
assignee = "john@smith.com"

```

--------------------------------

### List All Jira User Groups

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Lists all known user groups in the Jira instance. Supports pagination with optional --offset and --limit arguments. Returns a table with group IDs and names.

```shell
jiratui users groups
```

--------------------------------

### Search Jira Issues via CLI

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

This command searches for Jira issues using a specific issue key. It requires the JiraTUI CLI to be installed and configured. The output will display the details of the found issue.

```bash
jiratui issues search --key SCRUM-42
```

--------------------------------

### Focus JiraTUI on Specific Work Item at Startup

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Enables JiraTUI to focus on and open a specific work item from the search results immediately upon startup. This requires --search-on-startup to be enabled and takes a 1-based position index of the desired item. It can be combined with other filters like project key or JQL expression ID.

```shell
jiratui ui --search-on-startup --focus-item-on-startup 1
```

```shell
jiratui ui --project-key PROJECT-1 --search-on-startup --focus-item-on-startup 1
```

```shell
jiratui ui --jql-expression-id 1 --search-on-startup --focus-item-on-startup 3
```

--------------------------------

### Python API - Get Projects and Users

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Demonstrates searching for projects, retrieving project details and statuses, and searching for users (including assignable users) using the JiraTUI Python API. Requires the 'jiratui' library and a valid Jira API configuration. It takes search queries and project keys as input and outputs project and user information.

```python
import asyncio
from jiratui.api.api import JiraAPI
from jiratui.config import ApplicationConfiguration

config = ApplicationConfiguration()
api = JiraAPI(
    base_url=config.jira_api_base_url,
    api_username=config.jira_api_username,
    api_token=config.jira_api_token.get_secret_value(),
    configuration=config
)

async def get_projects_and_users():
    try:
        # Search projects
        projects = await api.search_projects(
            query='SCRUM',  # Case-insensitive search
            limit=50,
            offset=0,
            order_by='name'
        )

        print("Projects:")
        for project in projects.get('values', []):
            print(f"  {project['key']}: {project['name']}")

        # Get specific project
        project = await api.get_project('SCRUM')
        print(f"\nProject: {project['name']}")
        print(f"Lead: {project.get('lead', {}).get('displayName', 'None')}")

        # Get project statuses
        statuses = await api.get_project_statuses('SCRUM')
        print("\nAvailable statuses by issue type:")
        for status_group in statuses:
            issue_type = status_group['name']
            print(f"  {issue_type}:")
            for status in status_group.get('statuses', []):
                print(f"    - {status['name']} (ID: {status['id']})")

        # Search users
        users = await api.user_search(
            query='bart',
            limit=50
        )

        print("\nUsers:")
        for user in users:
            print(f"  {user['displayName']} - {user['emailAddress']} (ID: {user['accountId']})")

        # Get assignable users for project
        assignable_users = await api.user_assignable_search(
            project_id_or_key='SCRUM',
            query='simpson',
            limit=50
        )

        print("\nAssignable users:")
        for user in assignable_users:
            print(f"  {user['displayName']} (ID: {user['accountId']})")

    except Exception as e:
        print(f"Error: {e}")

asyncio.run(get_projects_and_users())

```

--------------------------------

### Search Jira User Groups by Name

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Searches for a specific Jira user group by its exact name. Returns a table with the group's ID, name, and total users.

```shell
jiratui users groups --group-names developers
```

--------------------------------

### Python API: Connect to Jira Data Center/On-Premises

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

This Python code configures and connects to Jira Data Center or on-premises installations using `JiraDataCenterAPI`. It highlights the importance of setting `cloud=False` in `ApplicationConfiguration` and specifies that some features available in cloud instances might not be present in Data Center. The API usage is generally consistent with the cloud `JiraAPI`.

```python
from jiratui.api.api import JiraDataCenterAPI
from jiratui.config import ApplicationConfiguration

# Configuration for on-premises
config = ApplicationConfiguration(
    jira_api_username='admin',
    jira_api_token='your-token',
    jira_api_base_url='https://jira.company.com',
    cloud=False  # Important: set to False for on-premises
)

# Use JiraDataCenterAPI for on-premises
api = JiraDataCenterAPI(
    base_url=config.jira_api_base_url,
    api_username=config.jira_api_username,
    api_token=config.jira_api_token.get_secret_value(),
    configuration=config
)

# API usage is similar to JiraAPI
# Note: Some features like approximate count are not available in Data Center

```

--------------------------------

### Python API: Select Jira REST API Version (v2 or v3)

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

This Python example shows how to select between Jira REST API v2 and v3 using the `jiratui` library. API v3 is the default and supports Atlassian Document Format (ADF), while API v2 is used for plain text comments without ADF. The `jira_api_version` parameter in `ApplicationConfiguration` controls this selection.

```python
from jiratui.api.api import JiraAPI, JiraAPIv2
from jiratui.config import ApplicationConfiguration

# Use API v3 (default, supports ADF - Atlassian Document Format)
config_v3 = ApplicationConfiguration(
    jira_api_username='user@example.com',
    jira_api_token='token',
    jira_api_base_url='https://instance.atlassian.net',
    jira_api_version=3  # Default
)

api_v3 = JiraAPI(
    base_url=config_v3.jira_api_base_url,
    api_username=config_v3.jira_api_username,
    api_token=config_v3.jira_api_token.get_secret_value(),
    configuration=config_v3
)

# Use API v2 (plain text comments, no ADF)
config_v2 = ApplicationConfiguration(
    jira_api_username='user@example.com',
    jira_api_token='token',
    jira_api_base_url='https://instance.atlassian.net',
    jira_api_version=2
)

api_v2 = JiraAPIv2(
    base_url=config_v2.jira_api_base_url,
    api_username=config_v2.jira_api_username,
    api_token=config_v2.jira_api_token.get_secret_value(),
    configuration=config_v2
)

```

--------------------------------

### JiraTUI CLI: Basic Commands and Shell Completions

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

This section covers essential command-line interface (CLI) commands for JiraTUI, including checking the version, locating the configuration file, listing themes, and generating shell completion scripts for Bash, Zsh, and Fish. These commands help users manage and interact with JiraTUI from their terminal.

```bash
# View version
jiratui version

# Show config file location
jiratui config

# List available themes
jiratui themes

# Generate shell completions
jiratui completions bash > ~/.bash_completion.d/jiratui
jiratui completions zsh > ~/.zsh/completions/_jiratui
jiratui completions fish > ~/.config/fish/completions/jiratui.fish

```

--------------------------------

### Launch JiraTUI TUI Application

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Launches the interactive Text User Interface (TUI) for JiraTUI. Supports various options for filtering by project, focusing on work items, applying themes, and triggering automatic searches. The configuration file can also be specified via an environment variable.

```bash
# Basic launch
jiratui ui

# Launch with specific project
jiratui ui --project-key SCRUM

# Launch with work item focused
jiratui ui --work-item-key SCRUM-123

# Launch with theme
jiratui ui --theme monokai

# Launch with search triggered automatically
jiratui ui --project-key SCRUM --search-on-startup

# Launch and focus on specific item (requires --search-on-startup)
jiratui ui --project-key SCRUM --search-on-startup --focus-item-on-startup 3

# Use custom config file
JIRA_TUI_CONFIG_FILE=/path/to/config.yaml jiratui ui

```

--------------------------------

### Generate Shell Completions for JiraTUI

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/usage/index.md

Generates shell completion scripts for bash, zsh, and fish. This helps in auto-completing commands and their arguments in the terminal. It requires the 'jiratui' executable and a specified shell type.

```shell
jiratui completions [bash|zsh|fish]
```

```shell
jiratui completions zsh
```

--------------------------------

### Run JiraTUI Application UI

Source: https://github.com/whyisdifficult/jiratui/blob/main/README.md

Launch the JiraTUI application's user interface. If you are using a custom configuration file, specify its path using the JIRA_TUI_CONFIG_FILE environment variable.

```shell
jiratui ui
```

```shell
JIRA_TUI_CONFIG_FILE=/path/to/cutom-file/my-file.yaml jiratui ui
```

--------------------------------

### Configure Jira API Credentials in YAML

Source: https://github.com/whyisdifficult/jiratui/blob/main/jtsite/getting-started.html

Set your Jira API username, token, and base URL within the configuration file. This is essential for the application to authenticate with your Jira instance.

```yaml
jira_api_username: 'bart@simpson.com'
jira_api_token: '12345'
jira_api_base_url: 'https://.atlassian.net'
```

--------------------------------

### Python API: Get Jira Issue Details

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Retrieves detailed information for a specific Jira issue using its key or ID. This function can fetch all fields and properties associated with an issue, including its summary, status, assignee, and edit metadata.

```python
import asyncio
from jiratui.api.api import JiraAPI
from jiratui.config import ApplicationConfiguration

config = ApplicationConfiguration()
api = JiraAPI(
    base_url=config.jira_api_base_url,
    api_username=config.jira_api_username,
    api_token=config.jira_api_token.get_secret_value(),
    configuration=config
)

async def get_issue_details():
    try:
        # Get issue with specific fields
        issue = await api.get_issue(
            issue_id_or_key='SCRUM-42',
            fields='*all',  # Get all fields
            properties='*all'  # Get all properties
        )

        fields = issue['fields']
        print(f"Issue: {issue['key']}")
        print(f"Summary: {fields['summary']}")
        print(f"Status: {fields['status']['name']}")
        print(f"Assignee: {fields.get('assignee', {}).get('displayName', 'Unassigned')}")
        print(f"Priority: {fields.get('priority', {}).get('name', 'None')}")
        print(f"Created: {fields['created']}")
        print(f"Updated: {fields['updated']}")

        # Access edit metadata
        if 'editmeta' in issue:
            print("\nEditable fields:")
            for field_key, field_data in issue['editmeta'].get('fields', {}).items():
                print(f"  - {field_data.get('name', field_key)}")

    except Exception as e:
        print(f"Error: {e}")

asyncio.run(get_issue_details())
```

--------------------------------

### Search Jira Issues via CLI

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Performs issue searches using the JiraTUI command-line interface. Allows filtering by project key, issue key, assignee, creation date range, and limiting the number of results. The output is presented in a tabular format.

```bash
# Search by project key
jiratui issues search --project-key SCRUM

# Output:
# | Key     | Type | Created          | Status (ID)   | Reporter          | Assignee          | Summary                                    | 
# |---------|------|------------------|---------------|-------------------|-------------------|--------------------------------------------| 
# | SCRUM-1 | Bug  | 2025-07-31 15:55 | To Do (10000) | lisa@simpson.com  | bart@simpson.com  | Write 100 times "I will be a good student" | 
# | SCRUM-2 | Task | 2025-06-30 15:56 | To Do (10000) | homer@simpson.com | homer@simpson.com | Eat donuts                                 | 

# Search specific issue by key
jiratui issues search --key SCRUM-42

# Search with assignee filter
jiratui issues search --project-key SCRUM --assignee-account-id 5d123abc456def789

# Search with date range
jiratui issues search --project-key SCRUM --created-from 2025-01-01 --created-until 2025-12-31

# Search with result limit
jiratui issues search --project-key SCRUM --limit 10

```

--------------------------------

### Configure Jira Data Center Connection (YAML)

Source: https://github.com/whyisdifficult/jiratui/blob/main/docs/users/configuration/index.md

Shows how to configure JiraTUI to connect to a Jira Data Center (on-premises) instance. This is done by setting the `cloud` option to `False` in the `config.yaml` file.

```yaml
cloud: False
```

--------------------------------

### Advanced Configuration - API Version Selection

Source: https://context7.com/whyisdifficult/jiratui/llms.txt

Select between Jira REST API v2 and v3 when initializing the `JiraAPI` or `JiraAPIv2` client, impacting features like comment formatting (ADF support).

```APIDOC
## Advanced Configuration - API Version Selection

### Description
Choose which version of the Jira REST API (v2 or v3) the `jiratui` library should interact with. API v3 is the default and supports the Atlassian Document Format (ADF) for richer content, while v2 uses plain text for comments.

### Method
Python class instantiation and API calls.

### Endpoint
N/A (Configuration and API client setup)

### Parameters
#### `ApplicationConfiguration` for API Version
- **jira_api_version** (int) - Optional - Set to `3` for API v3 (default) or `2` for API v2.

#### API Client Constructors
- **`JiraAPI`**: Initializes with API v3 by default. Can be configured for v2 via `ApplicationConfiguration`.
- **`JiraAPIv2`**: Explicitly initializes with API v2.

### Request Example
```python
from jiratui.api.api import JiraAPI, JiraAPIv2
from jiratui.config import ApplicationConfiguration

# Use API v3 (default, supports ADF - Atlassian Document Format)
config_v3 = ApplicationConfiguration(
    jira_api_username='user@example.com',
    jira_api_token='token',
    jira_api_base_url='https://instance.atlassian.net',
    jira_api_version=3  # Explicitly setting v3 (default behavior)
)

api_v3 = JiraAPI(
    base_url=config_v3.jira_api_base_url,
    api_username=config_v3.jira_api_username,
    api_token=config_v3.jira_api_token.get_secret_value(),
    configuration=config_v3
)

# Use API v2 (plain text comments, no ADF)
config_v2 = ApplicationConfiguration(
    jira_api_username='user@example.com',
    jira_api_token='token',
    jira_api_base_url='https://instance.atlassian.net',
    jira_api_version=2
)

# Option 1: Using JiraAPI with explicit v2 configuration
api_v2_via_config = JiraAPI(
    base_url=config_v2.jira_api_base_url,
    api_username=config_v2.jira_api_username,
    api_token=config_v2.jira_api_token.get_secret_value(),
    configuration=config_v2
)

# Option 2: Using the dedicated JiraAPIv2 class
api_v2_dedicated = JiraAPIv2(
    base_url=config_v2.jira_api_base_url,
    api_username=config_v2.jira_api_username,
    api_token=config_v2.jira_api_token.get_secret_value(),
    configuration=config_v2
)
```

### Response
N/A (This section describes setup, not direct responses.)

### Notes
- API v3 is recommended for modern Jira Cloud instances due to ADF support.
- API v2 is suitable for older instances or when ADF is not required.

```

--------------------------------

### JiraTUI CLI: Search Issues by Project Key

Source: https://github.com/whyisdifficult/jiratui/blob/main/README.md

Search for all issues within a specific Jira project using the 'jiratui issues search' command with the '--project-key' argument. The project key is case-sensitive.

```shell
$ jiratui issues search --project-key SCRUM
```