Terminal UI for issue tracking
npm install @sascha384/ticA terminal UI for issue tracking, built for developers who live in the terminal. Track work items across multiple backends — local markdown files, GitHub Issues, GitLab Issues, Azure DevOps Work Items, and Jira.
Built with TypeScript and Ink.
- Keyboard-driven TUI — browse, create, edit, and manage work items without leaving the terminal
- Multiple backends — local markdown, GitHub (via gh), GitLab (via glab), Azure DevOps (via az), Jira (via REST API)
- Automatic backend detection — selects backend based on git remote, or configure manually
- Local markdown storage — work items stored as markdown files with YAML frontmatter in a .tic/ directory
- CLI commands — scriptable commands for all operations (tic item list, tic item create, etc.)
- Work item types — organize by epic, issue, and task (configurable)
- Iterations — group work into sprints or milestones
- Parent-child relationships — build hierarchies with collapsible tree-indented views
- Dependencies — track which items block others, with warnings on premature completion
- Priority & assignee — track who owns what and what's most important
- Comments — add timestamped comments to any work item
- Bulk operations — mark multiple items and change status, type, priority, assignee, labels, or parent in batch
- Quick search — fuzzy search across all work items regardless of type or iteration
- Detail panel — inline preview of selected item with metadata, description, and scroll support
- Undo — undo delete, create, and property changes with u (up to 5 actions deep)
- External editor — edit descriptions in your $EDITOR (falls back to vi)
- Settings screen — switch backends and configure Jira connection from within the TUI
- MCP server — expose work items to AI assistants via the Model Context Protocol
``bash`
npm install -g @sascha384/tic
`bash`
cd your-project
tic init # Initialize (auto-detects backend from git remote)
tic # Launch the TUI
For local storage, tic init creates a .tic/ directory to store your work items. For GitHub, GitLab, or Azure DevOps projects, it detects the backend from the git remote automatically. You can also specify a backend explicitly:
`bash`
tic init --backend github
tic init --backend gitlab
tic init --backend azure
tic init --backend jira
tic init --backend local
The main screen shows work items filtered by type and iteration, displayed as a collapsible tree that reflects parent-child relationships. In narrow terminals (< 80 columns) the display switches to a card layout.
| Key | Action |
|-----|--------|
| ↑ ↓ | Navigate between items |←
| | Collapse children or jump to parent |→
| | Expand children |PageUp
| PageDown | Jump by viewport height |Home
| End | Jump to first/last item |Enter
| | Edit selected item |c
| | Create new work item |d
| | Delete item(s) (with confirmation) |u
| | Undo last action (delete, create, or property change) |o
| | Open item in browser/editor |v
| | Toggle detail panel |Space
| | Expand full description in detail panel |/
| | Quick search across all items |:
| | Command palette |s
| | Set status (single or marked items) |S
| | Sync status screen |p
| | Set parent for selected item |m
| | Toggle mark on current item |M
| | Clear all marks |B
| | Bulk actions menu |P
| | Set priority (single or marked items) |a
| | Set assignee (single or marked items) |l
| | Set labels (single or marked items) |t
| | Set type (single or marked items) |Tab
| | Cycle work item type filter (epic / issue / task) |i
| | Iteration picker |,
| | Settings |b
| | Create branch / worktree for item (requires git) |r
| | Sync with remote backend |?
| | Show keyboard shortcuts |q
| | Quit |
The list displays ID, title (tree-indented), status, priority, and assignee. Items with dependencies show a ⧗ indicator. Marked items are highlighted — bulk actions apply to all marked items, or to the cursor item if none are marked.
Press Enter on an item or c to create one. The form has these fields:
- Title — name of the work item
- Type — epic, issue, or task (dropdown)
- Status — backlog, todo, in-progress, review, done (dropdown)
- Iteration — which sprint/milestone this belongs to (dropdown)
- Priority — low, medium, high, critical (dropdown)
- Assignee — who owns this (autocomplete from existing assignees)
- Labels — comma-separated tags (autocomplete from existing labels)
- Description — full details (opens $EDITOR on Enter)
- Parent — ID of the parent item (autocomplete from existing items)
- Depends On — comma-separated IDs of items this depends on (autocomplete)
- Comments — add new comments; existing comments shown as read-only
Navigate fields with ↑ ↓, press Enter to edit a field, and Esc to save and return to the list. Press ? for help. When editing a related item in the relationships section, pressing Enter navigates to that item (and Esc navigates back through the stack).
Press i in the list view to open the iteration picker. The current iteration filters which items you see. New iterations are created automatically when you assign an item to one that doesn't exist yet.
Parent-child: Set a parent ID on an item to nest it under another. Children appear indented in the tree view. Circular parent chains are prevented.
Dependencies: Add dependency IDs to indicate that an item is blocked by others. When you try to complete an item that has open children or unresolved dependencies, tic shows a warning so you can decide whether to proceed.
Deleting an item automatically cleans up references — children have their parent cleared, and the item is removed from other items' dependency lists.
Work items live in .tic/ at the root of your project:
`
.tic/
├── config.yml # Types, statuses, iterations, settings
├── items/
│ ├── 1.md # Work item #1
│ ├── 2.md # Work item #2
│ └── ...
├── templates/ # Work item templates
│ └── bug-report.md # Template with YAML frontmatter
└── trash/ # Soft-deleted items (for undo)
Each item is a markdown file with YAML frontmatter:
`markdown
---
id: 1
title: Implement user login
type: task
status: in-progress
iteration: sprint-1
priority: high
assignee: alice
labels: auth, backend
parent: 3
depends_on:
- 2
created: 2026-01-15T10:00:00.000Z
updated: 2026-01-20T14:30:00.000Z
---
Full description of the work item goes here.
---
author: alice
date: 2026-01-18T09:00:00.000Z
Decided to use JWT tokens for this.
`
Configuration in .tic/config.yml:
`yaml`
types:
- epic
- issue
- task
statuses:
- backlog
- todo
- in-progress
- review
- done
iterations:
- default
current_iteration: default
next_id: 1
You can edit these files directly — they're plain text. Customize types, statuses, and iterations by editing config.yml.
`bash`
claude plugin marketplace add fa-krug/tic
claude plugin install tic
That's it. The plugin installs tic automatically on first use.
- List, search, create, update, and delete work items
- Navigate parent-child hierarchies and dependencies
- Add comments and manage iterations
- Initialize tic in new projects
The plugin auto-detects your backend (GitHub, GitLab, Azure DevOps, Jira, or local) and adapts to its capabilities.
`bash`
claude plugin update tic@tic
Or enable auto-updates for the tic marketplace in Claude Code settings.
tic also provides a full CLI for scripting and automation:
`bash`
tic item list # List work items
tic item list --status in-progress # Filter by status
tic item list --type task # Filter by type
tic item show 42 # Show item details
tic item create --title "Fix bug" # Create an item
tic item update 42 --status done # Update an item
tic item delete 42 # Delete an item
tic item comment 42 --body "Done" # Add a comment
tic item open 42 # Open in editor/browser
tic iteration list # List iterations
tic iteration set sprint-2 # Set current iteration
tic config get backend # Get config value
tic config set backend github # Set config value
Add --json to any command for machine-readable output, or --quiet to suppress non-essential output.
| Backend | CLI Tool | Detection |
|---------|----------|-----------|
| Local markdown | — | Default fallback |
| GitHub Issues | gh | github.com in git remote |glab
| GitLab Issues | | gitlab.com in git remote |az
| Azure DevOps Work Items | | dev.azure.com or visualstudio.com in git remote |
| Jira | REST API | Configured via settings |
Each backend supports a different set of capabilities (types, statuses, iterations, relationships, etc.). The TUI and CLI automatically adapt to show only what the active backend supports.
You can switch backends from within the TUI by pressing , to open settings. For Jira, you'll need to configure your site URL, project key, and optionally a board ID.
Azure DevOps requires the Azure CLI (az) with the azure-devops extension. There are two authentication methods, and both are recommended for full functionality:
| Method | Command | What it enables |
|--------|---------|-----------------|
| PAT (Personal Access Token) | az devops login | Work items, queries, iterations, relations |az login
| Azure AD / Entra ID | | Comments (read and write) |
The Work Item Comments API is a preview endpoint that requires Azure AD tokens. If you only use az devops login, everything works except comments — they will silently be unavailable when viewing items and explicitly fail when adding comments.
For full functionality:
`bash``
az login # Azure AD — needed for comments
az devops login # PAT — needed for work items
See CONTRIBUTING.md for development setup, architecture, and conventions.