A modern, extensible Go CLI tool for developer workflow automation. This tool replaces a complex bash script with a maintainable, feature-rich application that integrates with Git worktrees, Tmux sessions, Markdown documentation, and command history tracking.

• Ticket-based workflows: Initialize complete work environments with a single command
• Git worktree integration: Automatic isolated workspaces per ticket
• Tmux session management: Configurable multi-window terminal sessions
• Markdown note creation: Template-based documentation with JIRA integration
• Command history tracking: SQLite-based timeline export and analysis

• Git: Automatic worktree and branch creation with base branch detection
• JIRA: Ticket metadata fetching via configurable CLI tools (acli)
• Markdown: Rich note templates, daily note updates, timeline export
• Tmux: Session automation with environment variables and window layouts
• History Databases: Support for both zsh-histdb and atuin SQLite schemas

1. Clone the repository:

   git clone <repository-url>
   cd rig

2. Build the CLI:

   cd main/
   go build -o rig

3. Initialize configuration:

   ./rig config --init

4. Edit configuration at ~/.config/rig/config.yaml:

   vault:
   path: "~/Documents/Second Brain"
   repository:
   owner: "your-org"
   name: "your-repo"
   base_path: "~/src"

1. Start working on a ticket:

   ./rig work proj-123

   This creates:

   • Git worktree at ~/src/your-org/your-repo/proj/proj-123
   • Markdown note with JIRA details
   • Tmux session with note/code/terminal windows
   • Daily note entry with timestamp

2. Export your work timeline:

   ./rig timeline proj-123

3. Sync latest information:

   ./rig sync proj-123

The CLI uses TOML configuration at ~/.config/rig/config.toml:

For working with multiple repositories, use the repositories table with ticket_types to route tickets:

With multi-repo config, rig work proj-123 routes to main-repo while rig work ops-456 routes to infra-repo.

Rig supports two modes for fetching Jira ticket information: direct API access (recommended) and ACLI (legacy).

Direct API integration provides faster performance and richer metadata without external dependencies.

1. Create an API token at https://id.atlassian.com/manage/api-tokens

2. Set the token as an environment variable (preferred):

   export JIRA_TOKEN="your-api-token"

3. Configure rig:

   [jira]
   enabled = true
   mode = "api"
   base_url = "https://your-domain.atlassian.net"
   email = "your-email@example.com"
   # token can be set via JIRA_TOKEN env var (preferred) or token field
   
   [jira.custom_fields]
   story_points = "customfield_10016"

   To find your custom field IDs, use the Jira REST API or check your Jira admin settings.

For users who prefer the Atlassian CLI tool:

Ensure acli is installed and configured with your Jira credentials before using this mode.

Start complete workflow for a ticket.

Example:

What it does:

• Creates git worktree and branch
• Fetches JIRA ticket details (if configured)
• Creates Markdown note from template
• Updates daily note with timestamp
• Launches tmux session with configured windows

Lightweight workflow for non-ticket work (experiments, spikes, etc.).

Example:

Options:

• --notes - Also create an Markdown note for the hack session

What it does:

• Creates git worktree at hack/ with branch hack/
• Creates tmux session
• Skips JIRA integration (no ticket needed)
• Optionally creates Markdown note with --notes flag

Show all worktrees and tmux sessions across configured repositories.

Options:

• --worktrees - Show only worktrees
• --sessions - Show only tmux sessions

Remove old worktrees and associated tmux sessions.

Options:

• --dry-run - Show what would be removed without removing
• --force - Skip confirmation prompts

Generate and export command timeline to Markdown.

Options:

• --since "2025-08-10 09:00" - Start time filter
• --until "2025-08-10 18:00" - End time filter
• --failed-only - Show only failed commands
• --directory /path - Filter by directory
• --limit 1000 - Max commands to retrieve
• --output file.md - Write to file instead of note
• --no-update - Only output to console

Examples:

List all active tmux sessions.

Attach to existing tmux session for a ticket.

Kill tmux session for a ticket.

Query command history database.

Options:

• --since "2025-08-10" - Start time filter
• --until "2025-08-10" - End time filter
• --directory /path - Filter by directory
• --session name - Filter by session name
• --failed-only - Show only failed commands
• --limit 50 - Max results to show

Examples:

Show information about the history database.

Update ticket note with fresh JIRA information and daily notes.

Options:

• --jira - Force refresh of JIRA information
• --daily - Update today's daily note only
• --force - Force update even if recently modified

Update today's daily note.

Display current configuration.

Create default configuration file.

• Git: For repository and worktree management
• Tmux: For session management
• Neovim: For editing (configurable)

• JIRA CLI: acli or similar for ticket metadata
• History Database: zsh-histdb or atuin for command tracking
• Obsidian: For note management and templates

Your Markdown vault should have this structure (subdirs are configurable):

• github.com/spf13/cobra - CLI framework
• github.com/spf13/viper - Configuration management
• github.com/mattn/go-sqlite3 - SQLite database access
• gopkg.in/yaml.v3 - YAML parsing

The project has comprehensive test coverage across all packages.

• Table-driven tests: Most tests use Go's table-driven pattern for comprehensive coverage
• Mock-based unit tests: pkg/git uses CommandRunner interface for mocking git commands
• Integration tests: Some tests create real git repos in temp directories (skipped if git unavailable)

• cmd/ - 9 test files covering all commands except root.go
• pkg/config/ - Configuration loading and validation
• pkg/git/ - Mock-based worktree operations testing
• pkg/history/ - Database schema detection and query building
• pkg/jira/ - JIRA CLI output parsing
• pkg/obsidian/ - Note and template management
• pkg/tmux/ - Session parsing and management

1. Create new command file in cmd/
2. Add command to root command in init()
3. Implement business logic in appropriate pkg/ package
4. Add corresponding _test.go file with table-driven tests

This CLI tool replaces the original rig.sh bash script with the following improvements:

• Better error handling: Graceful degradation and detailed error messages
• Rich configuration: YAML-based with validation and path expansion
• Advanced querying: SQLite database integration with filtering
• Timeline export: Formatted command history with metadata
• Extensible architecture: Easy to add new commands and integrations

1. Install and configure the Go CLI
2. Test with existing tickets to ensure compatibility
3. Gradually replace bash script usage
4. Remove bash script once comfortable with CLI

• Command history analysis and export
• Advanced tmux session management
• Configurable window layouts
• Multiple history database support
• Rich timeline formatting

1. Fork the repository
2. Create a feature branch
3. Make changes with tests
4. Submit a pull request

• Follow Go best practices
• Use the existing package structure
• Add comprehensive error handling
• Include appropriate logging

[Add your license here]

For issues and questions:

1. Check existing issues in GitHub
2. Create new issue with detailed description
3. Include configuration and error logs

Note: This tool is designed for Developer workflow automation and integrates with multiple external tools. Ensure all prerequisites are installed and configured for full functionality.