imdone-cli 💡

Manage Jira issues, comments, and attachments alongside your code.

Prerequisites

• Node.js v22 or higher installed
• git installed
• Jira account with API access
• A Jira API token with read and write permissions for the project
• A git repository used for your software development

Get started:

# 1) Install
npm i -g imdone-cli

# 2) Initialize and pull issues
imdone init

# 3) Open stories in your editor (Markdown next to your code)
code . # nvim .

What you'll see: A backlog/current-sprint/ directory with organized folders—one per Jira issue. Each issue folder contains the main issue content (issue-PROJ-123.md), comments (comments-PROJ-123.md), and an attachments/ folder. Edit markdown locally; imdone push syncs changes back to Jira.

backlog/
├── .imdone/
│   ├── config.yml
│   └── templates/
│       └── story.md
├── current-sprint/
│   ├── PROJ-123-Fix_login_bug/
│   │   ├── attachments/
│   │   │   └── error-screenshot.png
│   │   ├── comments-PROJ-123.md
│   │   └── issue-PROJ-123.md
│   └── PROJ-124-Add_user_dashboard/
│       ├── attachments/
│       ├── comments-PROJ-124.md
│       └── issue-PROJ-124.md

Two commands you'll use a lot

**What you'll see:** a `backlog/current-sprint/` directory with organized folders—one per Jira issue. Each issue folder contains the main issue content (`issue-PROJ-123.md`), comments (`comments-PROJ-123.md`), and an `attachments/` folder. Edit markdown locally; `imdone push` syncs changes back to Jira.

## Two commands you’ll use a lot

```bash
imdone pull   # Bring Jira issues/comments/attachments into Markdown
imdone push   # Push your Markdown edits back to Jira

Uninstall anytime: imdone destroy && npm uninstall -g imdone-cli (your code is untouched; backlog/ is git-ignored).

🙋 Support & Feedback

Found a bug or have a feature request? We'd love to hear from you!

• Website: imdone.io
• Email: [email protected]
• Discord: Join our Imdone users group for real-time support and discussions

🔧 Commands

📋 Output Formats: Many commands support the -f, --format option to change output format. Available formats are: json, yaml, csv, text (default).

init – Initialize Jira Integration

imdone init

Options:

• --name
• --jira-url
• --jira-project-key
• --jira-username
• --jira-api-token
• --jql

clone – Clone Remote Backlog Repository

imdone clone

Options:

• --remote-url
• --backlog-dir

Clones a remote backlog for easy onboarding.

update – Update imdone-cli Config

imdone update

Pull imdone-cli config from origin/main (using "theirs" strategy).

pull – Pull Issues from Jira

imdone pull

Options:

• -f, --format <format> - Output format: json, yaml, csv, text (default: text)

Fetches issues, comments, and attachments from Jira. Stashes local changes if needed, updates markdown files, and restores your changes.

What gets pulled:

• Issue content and metadata
• All comments (see Comments Made Simple)
• All attachments (see Attachments Without the Browser)
• Status and field updates

push – Push Changes to Jira

imdone push

Lints, pulls, extracts updates, and syncs with Jira.

What gets pushed:

• Issue content and metadata changes
• New comments (see Comments Made Simple)
• New attachments (see Attachments Without the Browser)
• Labels
• Validates markdown formatting for Jira compatibility

💡 Pro Tip: Use commentRequired:true in task metadata to enforce comments on critical issues before pushing to Jira.

add – Create New Jira Issue

imdone add

Alias: a

Creates a new Jira issue through an interactive guided process, or using provided options.

Options:

• --project-key [projectKey] - Jira project key to create the issue in (e.g., PROJ)
• --template [template] - Template to use for the issue (e.g., story, bug)
• --issue-type [issueType] - Jira issue type (e.g., Story, Task, Bug)
• --location [location] - Issue location: "backlog" or "sprint"
• --sprint-id [sprintId] - Sprint ID when location is "sprint"
• --summary [summary] - Issue summary/title
• -f, --format <format> - Output format: json, yaml, csv, text (default: text)

Examples:

# Create issue with all options specified
imdone add --project-key PROJ --template story --issue-type Story --location sprint --sprint-id 123 --summary "New feature request" --format json

# Create issue in specific project (interactive mode for other options)
imdone add --project-key PROJ

Interactive prompts (when options not provided):

1. Template selection - Choose from available templates in .imdone/templates
2. Project selection - Choose which Jira project to create the issue in (only shown when multiple projects are configured)
3. Issue type - Select from Jira issue types (Story, Task, Bug, etc.)
4. Location - Choose current sprint or backlog
5. Summary - Enter the issue title/summary

What gets created:

• New Jira issue with specified type and summary
• Markdown content based on selected template (if any)
• Basic structure (Description, Acceptance Criteria, Tasks) if no template is used
• A replay command showing how to create similar issues without prompts

Templates: If your project has templates in .imdone/templates, they will be available for selection. Templates provide pre-structured content for consistent issue creation.

💡 Replay Command: After creating an issue, the CLI will display the exact command to create a similar issue without prompts:

💡 Next time, use: imdone add --project-key "PROJ" --template "story" --issue-type "Story" --location "backlog" --summary "Your issue title"

template – Apply Template to Existing Issue

imdone template

Alias: t

Applies a template to an existing Jira issue through an interactive guided process, or using provided options.

Options:

• --issue-key [issueKey] - Issue key to apply template to (e.g., PROJ-123)
• --template [template] - Template to apply (e.g., story, bug, dod)

Examples:

# Apply template with all options specified
imdone template --issue-key PROJ-123 --template dod

# Interactive mode - prompts for missing arguments
imdone template

# Prompt for template only
imdone template --issue-key PROJ-123

Interactive prompts (when options not provided):

1. Issue selection - Choose from available issues in current sprint
2. Template selection - Choose from available templates in .imdone/templates

What gets applied:

• Template metadata (tags, custom fields) is merged with existing metadata

Templates: Templates are markdown files stored in .imdone/templates that provide pre-structured content for consistent issue formatting. Templates can reference existing issue content using ${markdown} to incorporate the current issue content. A default story template is included.

merge – Resolve Conflicts

imdone merge

After resolving conflicts manually, run this to push fixes to Jira.

move – Move Issue to New Status

imdone move [<ISSUE_KEY>] [<STATUS>]

Alias: mv

Moves a Jira issue to a new status by performing a transition. If arguments are not provided, the command will prompt for them interactively.

Arguments:

• ISSUE_KEY - The Jira issue key (e.g., PROJ-123)
• STATUS - The target status name (case-insensitive)

Options:

• -f, --format <format> - Output format: json, yaml, csv, text (default: text)

Examples:

# Move issue with specified arguments
imdone move PROJ-123 "In Progress"

# Move issue and output in JSON format
imdone move PROJ-123 "In Progress" --format json

# Interactive mode - prompts for missing arguments
imdone move

# Prompt for status only
imdone move PROJ-123

The command automatically discovers available transitions for the issue and provides an interactive selection if the specified status is not valid.

lint – Lint Todo Comments

imdone lint

Checks and fixes formatting issues for compatibility with Jira.

reset – Reset Local Project State

imdone reset

Options:

• -f, --format <format> - Output format: json, yaml, csv, text (default: text)

Removes Jira integration state and pulls fresh data from Jira.

clean – Clean Project Data

imdone clean

Removes temporary files and data from the project without affecting the core configuration.

destroy – Remove Integration

imdone destroy

Deletes the config and backlog folder. Prompts for confirmation first.

license – Manage License

imdone license

Options:

• --token
• --show

Examples:

imdone license --token <your-token>
imdone license --show

show – Show Issue Details

imdone show [ISSUE_KEY]

Alias: s

Displays detailed information for a specific Jira issue including description, status, comments, and other fields. If no issue key is provided, you'll be prompted to search and select from existing issues.

Options:

• -f, --format <format> - Output format: json, yaml, csv, text (default: text)

Examples:

# Interactive mode - search and select issue
imdone show

# Default text format - markdown-like output
imdone show PROJ-123

# Text format (explicit)
imdone show PROJ-123 --format text
imdone show PROJ-123 -f text

# JSON format - structured data for automation
imdone show PROJ-123 --format json

# YAML format - preserves Jira markup and metadata
imdone show PROJ-123 --format yaml

# CSV format - tabular data
imdone show PROJ-123 --format csv

# Interactive mode with different format
imdone show --format json

list – Show Current Sprint Issues

imdone list

Alias: ls

Lists all issues in the current sprint by file path, or use custom JQL to filter specific issues.

Options:

• -l, --limit <number> - Limit the number of tasks displayed (default: 0, no limit)
• -f, --format <format> - Output format: json, yaml, csv, text (default: text)
• -j, --jql <query> - Override default JQL query to filter issues (e.g., "project = PROJ AND assignee = currentUser()")
• -v, --verbose - Show the JQL query being used

Examples:

# List all issues in text format (default)
imdone list

# List only 10 issues
imdone list --limit 10

# List issues in JSON format
imdone list --format json

# List limited issues in CSV format
imdone list --limit 5 --format csv

# List issues assigned to current user using custom JQL
imdone list --jql "project = PROJ AND assignee = currentUser()"

# List issues in specific status with verbose output
imdone list --jql "project = PROJ AND status = 'In Progress'" --verbose

# List issues from multiple projects
imdone list --jql "project IN ('PROJ1', 'PROJ2') AND status != 'Done'"

# List high priority issues only
imdone list --jql "project = PROJ AND priority IN ('High', 'Highest')"

# List issues with specific labels
imdone list --jql "project = PROJ AND labels = 'urgent'"

# List issues from current sprint
imdone list --jql "project = PROJ AND sprint in openSprints()"

# List recent issues (created in last 7 days)
imdone list --jql "project = PROJ AND created >= -7d"

JQL (Jira Query Language) Support:

The --jql option allows you to override the default project JQL configuration with custom queries. This gives you flexibility to view specific subsets of issues without modifying your main project configuration.

JQL Validation:

• JQL queries are validated before execution
• Must include a project specification (e.g., "project = PROJ")
• Provides helpful error messages with examples if validation fails
• Automatically suggests using configured project keys

Common JQL Patterns:

• project = KEY AND assignee = currentUser() - Issues assigned to you
• project = KEY AND status IN ("To Do", "In Progress") - Issues in specific statuses
• project = KEY AND sprint in openSprints() - Current sprint issues
• project = KEY AND fixVersion = "1.0.0" - Issues for specific version
• project = KEY AND created >= -7d - Recent issues
• project = KEY AND labels = "label-name" - Issues with specific labels

Note: When using custom JQL, the command fetches matching issues from Jira and then filters for those that exist in your local project. Use --verbose to see the exact JQL query being executed.

log – View Jira Changelog

imdone log [<ISSUE_KEY>] [--stats]

Shows changelog for an issue, with optional statistics. If no issue key is provided, you'll be prompted to search and select from existing issues.

Arguments:

• ISSUE_KEY - The Jira issue key (optional)

Options:

• --stats - Show statistics for the changelog
• -f, --format <format> - Output format: json, yaml, csv, text (default: text)

Examples:

# Show changelog for specific issue
imdone log PROJ-123

# Show changelog statistics for specific issue  
imdone log PROJ-123 --stats

# Show changelog in JSON format
imdone log PROJ-123 --format json

# Show changelog statistics in YAML format
imdone log PROJ-123 --stats --format yaml

# Interactive mode - search and select issue
imdone log

# Interactive mode with statistics
imdone log --stats

test – Test Configuration

imdone test

Validates connection and permission setup.

hooks – Git Hooks Management

Set up automatic imdone pull after git pull and imdone push before git push

imdone hooks setup

Options:

• --force - Overwrite existing git hooks

This sets up git hooks that automatically synchronize your Jira issues with git operations:

• post-merge hook: Runs imdone pull after each successful git pull to fetch the latest Jira issues
• pre-push hook: Runs imdone push before each git push to ensure your local Jira changes are synchronized

Remove git hooks

imdone hooks remove

Removes git hooks that were set up by imdone-cli.

How it works:

• Creates post-merge and pre-push hooks in .git/hooks/
• The hooks detect if the current directory has imdone configuration
• post-merge: Automatically runs imdone pull after successful git merges (which happen during git pull)
• pre-push: Automatically runs imdone push before git push operations
• The pre-push hook will cancel the push if imdone push fails (use git push --no-verify to bypass)
• Only runs for actual merges, not rebases
• Gracefully handles cases where imdone-cli is not available

📝 Markdown Formatting Guide

The imdone-cli includes automatic markdown formatting to ensure consistency across your project files. When you run imdone lint or imdone push, the following formatting rules are applied:

Formatting Rules

List Indentation

• All lists: Uses 4 spaces per indentation level for consistent formatting
• Ordered lists: Uses 4 spaces per indentation level
• Unordered lists: Uses 4 spaces per indentation level
• Mixed lists: All nested lists maintain the 4-space indentation standard
• Inconsistent indentation will be automatically fixed

Example of proper list formatting:

1. First ordered item
    - First unordered subitem (4 spaces)
        - Nested unordered item (8 spaces)
            - Deeper nested item (12 spaces)
2. Second ordered item
    - Another unordered subitem (4 spaces)

Code Blocks

• All code blocks must use fenced style with triple backticks (```)
• Code block indentation is normalized:
  • Fence markers (```) are moved to the left margin
  • Content within code blocks is reduced the same number of spaces as the fence indentation

Emphasis and Strong Styling

• Emphasis (italics): Use asterisks *like this* instead of underscores
• Strong (bold): Use double asterisks **like this** instead of underscores

Rules Not Enforced

• Line length: No maximum line length is enforced
• Bare URLs: URLs without formatting are allowed
• Trailing punctuation: Headings can end with punctuation marks

Additional markdownlint Rules

All default markdownlint rules are applied except for the overrides listed above. These include:

• Consistent heading styles
• Proper spacing
• List formatting
• And many other standard markdown best practices

How Violations Are Fixed

When you run imdone lint or as part of imdone push:

1. List indentation is automatically fixed
2. Code block indentation is normalized
3. markdownlint runs to fix remaining issues
4. All fixed content is saved back to your files

All fixes are applied automatically so you don't need to manually correct formatting issues. This ensures that markdown files remain consistently formatted across your project and compatible with Jira integration.

📖 Detailed Documentation

Working with Comments

You can add comments to Jira issues directly from your markdown files. Comments are automatically synchronized when you run imdone push.

How to add a comment:

1. Open the comments-<ISSUE_KEY>.md file for the issue you want to comment on
2. Add your comment in markdown format between the first line and the first --- separator
3. Run imdone push to sync the comment to Jira

Example:

# #TODO Comments: SCRUM-31 Enhance markdown to JIRA conversion

This is my new comment! I can use **bold**, _italic_, and other markdown formatting.

The comment supports multiple lines and will be converted to Jira markup automatically.

---

## Jesse Piascik | 2025-07-22T08:57:41.151-0400 | 10173

Here's another comment

---

After running imdone push, your comment will be posted to the Jira issue and the file will be updated to prevent duplicate posting.

Notes:

• Comments use markdown formatting that gets converted to Jira markup
• Only add content between the title line and the first --- separator

Requiring Comments for Tasks

You can enforce that certain tasks must have a comment before they can be pushed to Jira by adding commentRequired:true to the task's metadata.

Example task with required comment:

# #TODO Fix critical login bug 

This task will require a comment before it can be pushed to Jira.

<!--
jira:PROJ-123
commentRequired:true
-->

How it works:

1. When you run imdone push, the CLI checks if any tasks have commentRequired:true in their metadata
2. If a required comment is missing, you'll be prompted to enter one:

   Comment required for task "Fix critical login bug" (PROJ-123): 

3. The comment is automatically added to the corresponding comments-PROJ-123.md file
4. The push operation continues normally, syncing both the task and the new comment to Jira

When to use:

• Critical bugs that need explanation
• Complex features requiring documentation
• Tasks that affect multiple team members
• Any work item that benefits from context or reasoning

Working with Attachments

Imdone CLI automatically synchronizes attachments between Jira and your local project, making it easy to access files, images, and documents related to your issues without switching to the browser.

Automatic Download During Pull:

When you run imdone pull, all attachments from Jira issues are automatically downloaded to local attachments/ folders within each issue directory:

current-sprint/
├── PROJ-123-Fix_login_bug/
│   ├── attachments/
│   │   ├── error-screenshot.png
│   │   ├── debug-log.txt
│   │   └── .metadata.yml
│   ├── comments-PROJ-123.md
│   └── issue-PROJ-123.md

What gets downloaded:

• All attachment types: images, documents, logs, screenshots, etc.
• Original filenames are preserved
• File metadata is tracked in .metadata.yml for efficient synchronization
• Only new or changed attachments are downloaded on subsequent pulls

Attachment Features:

1. Intelligent Sync: Only downloads attachments that are new or have changed since the last pull
2. Size Validation: Verifies downloaded files match expected sizes from Jira
3. Metadata Tracking: Maintains local metadata to avoid unnecessary re-downloads
4. Error Handling: Gracefully handles download failures without stopping the pull process
5. Cleanup: Automatically removes local attachments that have been deleted from Jira

Accessing Attachments:

Once downloaded, attachments are available in your local file system:

• View images directly in your IDE or file explorer
• Open documents with your preferred applications
• Include attachment paths in documentation or code comments
• Reference attachments in markdown files using relative paths

Example Directory Structure:

backlog/current-sprint/
├── SCRUM-31-Enhance_markdown_conversion/
│   ├── attachments/
│   │   ├── my-profile-image.jpeg          # Downloaded from Jira
│   │   ├── requirements-document.pdf      # Downloaded from Jira
│   │   └── .metadata.yml                  # Tracks sync status
│   ├── comments-SCRUM-31.md
│   └── issue-SCRUM-31.md

Technical Notes:

• Attachments are downloaded to issue-specific folders to avoid conflicts
• The .metadata.yml file tracks download status and shouldn't be manually edited
• Attachment downloads respect your configured backlogDir from .imdone-cli.yml
• Large attachments are handled efficiently with automatic retry on failures
• HTTP redirects are properly handled for secure Jira attachment URLs

Customizing Your JQL Query

You can customize which Jira issues are pulled by modifying the JQL (Jira Query Language) in your project configuration:

Location: .imdone/config.yml

plugins:
  imdone-jira:
    jql: 'project = "YOUR-PROJECT" AND status != Done ORDER BY rank ASC'

Common JQL examples:

# Pull only issues assigned to you
jql: 'project = "PROJ" AND assignee = currentUser() AND status != Done ORDER BY rank ASC'

# Pull issues from specific sprint
jql: 'project = "PROJ" AND sprint in openSprints() ORDER BY rank ASC'

# Pull issues by labels
jql: 'project = "PROJ" AND labels in ("frontend", "backend") ORDER BY rank ASC'

# Pull issues from multiple projects
jql: 'project in ("PROJ1", "PROJ2") AND status != Done ORDER BY rank ASC'

# Pull only high priority issues
jql: 'project = "PROJ" AND priority in ("High", "Highest") ORDER BY rank ASC'

Tips:

• Use Jira's Query Builder in the web interface to test your JQL before adding it to config
• The ORDER BY rank ASC clause ensures issues appear in your backlog priority order
• After changing JQL, run imdone reset to refresh your local issues with the new query
• You can use Jira functions like currentUser(), openSprints(), and now()

⑂ imdone-cli and Git

Imdone CLI uses git to make it easier for the rest of your team to get the project configured. Git is also used to track changes to your backlog files, so you can resolve conflicts and easily revert to previous versions if needed.

In most cases, you should let imdone-cli handle Git operations for you. It’s designed to commit and sync changes safely so you can stay focused on your work.

If you run into a Git conflict, just resolve it in your editor, then run imdone merge.

🪲 Troubleshooting

Invalid License

Check your token:

imdone license --show

Jira Connection Issues

Ensure:

• Jira URL is correct
• API token is valid
• You have permissions

Debug Mode

imdone-debug pull > debug.log

Use for support diagnostics.

Changelog

0.27.0

• Multi-project support for issue creation: Enhanced imdone add command to support multiple Jira projects
  • Added --project-key option to specify which project to create the issue in (e.g., imdone add --project-key PROJ)
  • Interactive project selection prompt when multiple projects are configured in Jira adapter
  • Automatically uses the only configured project when just one is available
  • Project key validation with helpful feedback for invalid project keys
  • Replay command now includes the selected project key for future non-interactive use
  • Sprint options are now fetched for the selected project, ensuring accurate sprint assignment

0.26.0

• Fixed image rendering in Jira list items: Enhanced markdown-to-Jira conversion to properly handle images within list items
  • Images that appear directly in ordered or unordered list items are now moved to separate lines during Jira sync
  • Ensures images render correctly in Jira, which doesn't support inline images within list items

0.25.0

• Template System Enhancement: Added imdone template command for applying templates to existing Jira issues
  • Interactive prompts for issue selection and template application
  • Templates can include metadata (tags, custom fields) that gets merged with existing issue metadata
  • Template content can reference existing issue content using ${markdown} placeholder
  • Includes default story template created during imdone init
  • Perfect for applying Definition of Done (DoD) templates to existing stories
• JSON Metadata Format: Switched from YAML to JSON for issue metadata in comment blocks
  • Improved parsing reliability and consistency
  • Better integration with JavaScript-based tooling
  • Maintains backwards compatibility during transition
• Enhanced Documentation: Updated "What you'll see" section in README with more accurate project structure examples

0.24.4

• Remove the "command requires a Pro license." message after imdone pull
• Show a list of issues after imdone pull

0.24.3

1. Accurate Conversion of Jira Images

• Jira image macros like !image.png|width=100%! are now correctly converted to HTML <img> tags (or Markdown image syntax) with all attributes preserved (width, height, alt, etc.).
• When converting back from Markdown/HTML images to Jira markup, all attributes are retained. This means users won’t lose image sizing or alt text when roundtripping content.

2. Better Table Handling

• Blank lines are automatically added before and after tables when converting to Markdown, ensuring that Markdown renders tables correctly and consistently.
• Tables followed by images or other content are formatted so that display issues are avoided.

3. Improved Roundtrip Fidelity

• Complex Jira content (tables, images, quotes, lists) can be converted to Markdown and back to Jira without losing structure or formatting. This includes edge cases with images, tables, and block quotes.

4. Markdown Image Support

• Markdown syntax for images (![alt](url)) is now supported and converted to Jira image macros when syncing content to Jira.
• HTML <img> tags with attributes are also supported, making the conversion more flexible and user-friendly.

0.24.2

• Fixed blank lines getting removed from comments

0.24.1

• Fixed imdone clone

0.24.0

• Imdone CLI is free for up to 5 issues: Updated licensing model to allow free usage for small projects
  • Projects with 5 or fewer issues are now free to use imdone-cli without a license
  • Larger projects still require a valid license token for full functionality
  • Simplifies onboarding for small teams and individual developers

0.23.3

• Fixed comment formatting preservation: Enhanced comment formatting to maintain proper nested bullet structure during push operations
  • Nested bullet formatting in comments is now preserved when syncing to Jira
  • Ensures consistent formatting behavior between issues and comments

0.23.2

• Fixed inline code parsing: Enhanced JiraParser to correctly handle inline code that starts and ends with curly braces
  • Prevents malformed rendering when code contains pattern like {{variable}}
  • Improved regex pattern to avoid conflicts with Jira markup syntax
• Fixed header content parsing: Improved inline parsing of content within markdown headers
  • Headers now preserve their content correctly during markdown-jira conversion
• Enhanced table formatting in list output: Improved the imdone list command table display with dynamic column sizing
  • All columns (except summary) now auto-size based on actual content width for optimal space usage
  • URL column configured to never wrap, ensuring URLs remain readable and copy-able
  • Removed unnecessary padding to create more compact, efficient table layout
  • Summary column remains fixed-width for consistent formatting while other columns adapt to content

0.23.1

• Enhanced AI integration: Added AI instructions to all generated issue content
  • Issues now include context instructions for better AI-assisted development

0.23.0

• Fixed code preservation in markdown-jira conversion: Enhanced JiraParser to properly protect code content from formatting conversion
  • Asterisks and other formatting characters in inline code (backticks) and code blocks now preserve correctly
  • Prevents constants like MEDICARE*SECONDARY*PAYER_APPLIES from being corrupted during roundtrip conversion
• Fixed underscore preservation in identifiers: Enhanced JiraParser italic regex to prevent snake_case variables from being converted to italics
  • Constants like ONE_TWO_THREE_FOUR and SNAKE_CASE_VARIABLE_NAME now preserve correctly
  • Improved regex pattern requires word boundaries around italic markers to avoid matching identifier underscores

0.22.0

• Custom JQL support for list command: Enhanced imdone list and imdone ls commands with custom JQL query capability
  • Added --jql option to override default project JQL configuration for flexible issue filtering
  • Added --verbose option to display the actual JQL query being executed
  • Comprehensive JQL validation with helpful error messages and examples
  • Support for complex queries including assignee filters, status filters, sprint filters, and date ranges
  • Automatic project key validation and suggestions for configured projects
  • Seamless integration with existing output formats (text, json, yaml, csv) and limit options
  • Examples include filtering by assignee, status, labels, sprints, priority, and creation date
• Enhanced show command: Improved imdone show command with better format support and interactive prompts
  • Added --format option support for structured output (json, yaml, csv, text)
  • Interactive issue selection when no issue key is provided on command line
  • Improved markdown formatting for text output
• Improved move command: Fixed status display issues in transition prompts
  • Corrected "from status" display to show accurate current status
• Enhanced push feedback: Updated table format after push operations
  • Push results now display in same format as imdone ls for consistency
• Better project initialization: Enhanced imdone init command safety
  • Prevents running imdone init when .imdone-cli.yml file exists in ancestor directories
  • Protects against accidentally creating nested or conflicting configurations

0.21.0

• Improved file handling: Enhanced .gitignore file formatting
  • Adds proper newline before appending content to .gitignore files for cleaner formatting
• Enhanced Jira API compatibility: Added automatic API version fallback for better enterprise support
  • Automatically falls back to /rest/api/3/search/jql when /rest/api/2/search returns 410 - GONE
  • Improves compatibility with newer Jira instances that have deprecated v2 search API

0.20.1

• Enhanced user experience improvements: Improved interactive prompts and user feedback throughout the CLI
  • Added comprehensive issue summaries to selection prompts for better context
  • Enhanced feedback messages during git and Jira operations to keep users informed
  • Improved error handling and user guidance for common scenarios
• File handling optimization: Enhanced gitignore and imdoneignore file management
  • Prevents duplicate entries when appending content to .gitignore and .imdoneignore files
  • Smart content checking ensures cleaner configuration files
• Clear command enhancement: Made imdone clear command more robust
  • Now safely handles cases where no current-sprint directory exists
  • Eliminates unnecessary errors and provides better user feedback
• Documentation improvements: Streamlined README.md Key Features section for better developer experience
  • More concise and focused feature descriptions
  • Better organization of developer-focused information

0.19.0

• Enhanced output formatting: Added -f, --format option to major commands for structured data output
  • Supported formats: json, yaml, csv, text (default)
  • Available on: list, log, pull, add, move, reset commands
  • Perfect for automation, scripting, and integration with other tools
• Improved Jira table handling: Fixed conversion issues with empty table cells from Jira to markdown
• Better text formatting support: Enhanced handling of bold and italic text without requiring spaces
• Git commit enhancement: All imdone operations now include version information in commit messages for better tracking

0.18.2

• Fixed bug fatal: pathspec ...metadata.yml did not match any files

0.18.0

• Issue creation command: Added imdone add command for creating new Jira issues directly from the CLI
  • Interactive prompts for template selection, issue type, location (backlog/sprint), and summary
  • Command-line options support for automation: --template, --issue-type, --location, --sprint-id, --summary
  • Template integration from .imdone/templates for consistent issue structure
  • Automatic sprint assignment when creating issues for active sprints
  • Displays replay command after creation showing exact options for future use without prompts

0.17.1

• Fixed folder cleanup after status changes: Resolved issue where issue folders weren't automatically removed after using imdone move command
  • Issue folders are now properly cleaned up immediately after status transitions
  • No longer requires running imdone pull to remove empty issue folders
  • Improves workspace organization and reduces clutter

0.17.0

• Attachment upload support: Added ability to upload new attachments to Jira during imdone push
  • Automatically detects new files in attachments/ directories within issue folders
  • Uploads files to corresponding Jira issues and updates local metadata tracking
  • Includes author information (display name, email, account ID) in attachment metadata
  • Provides user feedback on successful uploads and handles errors gracefully
  • Maintains backwards compatibility with existing attachment download functionality

0.16.1

• Fixed attachment download functionality: Resolved critical issue with Jira attachment downloads
  • Fixed HTTP redirect handling in fetch adapter for binary downloads (Jira returns 303 redirects for attachments)
  • Enhanced file validation to ensure downloaded attachments match expected sizes
  • Improved error handling and debugging output for attachment download failures
  • Verified attachment downloads are properly saved to the configured backlogDir location
  • All attachment types (images, documents, etc.) now download correctly during imdone pull

0.16.0

• Enhanced move command with fuzzy search: Improved imdone move command with intelligent issue key selection
  • Added fuzzy search to issue key prompt for faster issue discovery
  • Automatically suggests existing issue keys from your project
  • Supports exact match, prefix match, contains match, and character sequence matching
  • Case-insensitive search with smart ranking
  • Fallback to manual input for new issue keys
• Enhanced log command with interactive prompts: Improved imdone log command with fuzzy search capabilities
  • Made issue key parameter optional - command now prompts for selection when not provided
  • Added fuzzy search functionality for issue key selection with intelligent ranking
  • Consistent user experience with the move command's interactive prompts
• Attachment synchronization: Added automatic attachment download during imdone pull
  • Downloads all issue attachments to local attachments/ folders
  • Preserves original filenames and supports all attachment types
  • Graceful error handling for failed downloads

0.15.0

• Issue status transitions: Added imdone move command to change Jira issue statuses directly from the command line
  • Use imdone move <issue-key> <status> to move an issue to a specific status
  • Interactive prompts when arguments are not provided
  • Automatic discovery of available transitions for each issue
  • Support for case-insensitive status matching
  • Alias: mv for shorter commands
  • Automatic sync: After successfully changing an issue's status, the command automatically runs imdone pull to sync the updated status to your local files. If the selected status is the same as the current status, no changes are made and no sync occurs.

0.14.1

• Make sure rank is using the correct field (Not obsolete one)

0.14.0

• Backlog ordering: Enhanced imdone list to display issues in proper rank order, making it easier to find the next most important things to work on
• Enhanced list command: Added --limit option to imdone list and imdone ls commands for controlling the number of displayed tasks
  • Use -l or --limit <number> to show only the first N tasks
  • Helpful for large projects with many issues
  • Shows informative feedback when limiting results (e.g., "showing first 5")
• Improved initialization flow: Enhanced imdone clone and imdone init commands with better help text and guidance links
  • Clearer prompts and instructions for new users
  • Better onboarding experience for Jira integration setup
• Comment file improvements: Added HTML comment headers to comments files for better organization
• Extended metadata support: Added assignee and reporter information to issue metadata
  • assignedTo: Display name of the person assigned to the issue
  • assignedToEmail: Email address of the assignee
  • reporter: Display name of the person who created the issue
  • reporterEmail: Email address of the reporter
  • Automatic field detection and mapping from Jira

0.13.0

• Comment requirements: Added commentRequired metadata support to enforce comments on specific tasks
  • Tasks with commentRequired:true must have a comment before they can be pushed to Jira
  • Interactive prompts guide users to add required comments during imdone push
  • Comments are automatically added to the appropriate comments file and synced to Jira
  • Git hooks properly handle interactive prompts with terminal input redirection

0.12.2

• Only update .gitignore files on init if the content doesn't already exist
• Replace .env values on init

0.12.1

• Exclude order metadata from getting saved to jira

0.12.0

• Add comments to jira issues with imdone push

0.11.8

• Git hooks integration: Added imdone hooks command with setup and remove subcommands for automatic synchronization
  • Post-merge hook automatically runs imdone pull after successful git pull operations
  • Pre-push hook runs imdone push before git push and blocks push if imdone sync fails
  • Hooks use smart directory resolution to find .imdone-cli.yml in git repository or parent directories
  • Force overwrite option available with --force flag for existing hook management
• Improved installation reliability: Enhanced preinstall and postinstall scripts to run from correct directory
• Optimized data handling: Removed encodedText from data processing to avoid unnecessary removeMD operations and improve performance

0.11.6

• Removed remark dependency: Eliminated unnecessary dependency to reduce package size and improve installation speed
• Fixed empty blockquote handling: Resolved issue where empty blockquotes were being added to markdown files, now uses blank lines instead for cleaner formatting
• Fixed ordered list numbering: Corrected issue where ordered list numbering continued across separate lists instead of restarting at 1
• Enhanced mixed list parsing: Improved Jira parsing and generation for ordered lists nested within unordered lists
• Automatic directory cleanup: Empty directories in current-sprint folder are now automatically removed after imdone pull to keep workspace clean
• Fixed concurrency race condition: Resolved race condition in throttledPromiseAll function that could cause operations to appear completed before all async work finished

0.11.0

• Standardized list formatting: All list nesting now uses consistent 4-space indentation for better readability and Jira compatibility
• Automated installation scripts: Added pre and post install scripts to check for uncommitted changes and automatically run updates
• Improved quote handling: Fixed issue where blockquotes were being moved to incorrect sections in files
• Better inline code processing: Fixed inline code spans being incorrectly interpreted as markdown formatting
• Multiple table support: Enhanced support for documents containing multiple markdown tables
• Updated ignore patterns: Added current-sprint/**/* to ignore files for better git management
• URL validation improvements: Fixed error when Jira URL contains trailing slash during imdone init
• Metadata in code blocks: Metadata is now stored in code blocks on Jira side and properly populated on pull without adding code blocks to markdown
• Comments file creation: Automatically creates separate comments files during imdone pull for better organization
• Enhanced markdown linting: Improved linter to normalize tables and clean up mixed ordered/unordered lists
• New directory structure: Implemented organized folder structure in current-sprint directory with individual folders per Jira item

0.10.2

• Fix prefix being added by Jira in ordered and unordered lists

0.10.1

• line breaks in tables on the jira side were causing the tables to break on the markdown side
  • Convert line breaks to <br> tags in markdown

0.10.0

• Enhanced markdown linting: Integrated markdownlint for improved code formatting and consistency
  • Code blocks are automatically unindented and normalized to proper formatting
  • Enforces consistent markdown standards across all backlog files
• Improved list command: Enhanced imdone list (alias ls) with better formatting
  • Added status display (TODO, DOING, etc.) for each issue
  • Output now displays as a formatted table for better readability
• Epic support: Added epic linking and metadata tracking
  • Epic information is now included in issue metadata
  • Automatic detection of epic custom field configuration
  • Epic links are preserved during Jira synchronization
• New show command: Added imdone show <ISSUE_KEY> command (alias s)
  • Display detailed issue information including description, status, and comments
  • Provides comprehensive view of Jira issue data from the command line