Taskfile Automation

# Task Automation System

Use this skill when working with projects that use [Task](https://taskfile.dev) to provide easy-to-discover automation commands for development workflows.

## Core Principle

**IMPORTANT**: Always prefer `task` commands over direct shell/language commands when a Taskfile is present.

Task provides:
- **Discoverability**: `task --list` shows all available tasks
- **Consistency**: Standardised commands across different environments
- **Documentation**: Built-in descriptions and help
- **Automation**: Multi-step workflows (e.g., `task dev` combines testing and docs)
- **Safety**: Interactive prompts for destructive operations

## Task Discovery

### Find Available Tasks

```bash
# List all available tasks with descriptions
task --list

# Show common workflows and usage patterns
task help

# Get detailed help for specific task
task <taskname> --help
```

**Always start with discovery** when entering a new project with a Taskfile.

## Common Task Patterns

### Development Workflows

Projects typically provide these standard tasks:

```bash
# Fast development cycle (common iteration loop)
task dev          # Usually runs fast tests + fast docs

# Pre-commit workflow
task precommit    # Runs pre-commit hooks + fast tests

# Full CI simulation locally
task ci           # Complete CI pipeline locally
```

### Testing Workflows

```bash
# Full test suite including quality checks
task test

# Fast tests (skip quality checks for rapid development)
task test-fast
task test:fast    # Alternative naming

# Quality checks only (Aqua, formatting, linting)
task test-quality
task test:quality
```

### Documentation Building

```bash
# Quick docs build (recommended for development)
task docs-fast
task docs:fast

# Full documentation including slow components (notebooks, etc.)
task docs

# Interactive documentation server
task docs-pluto   # For Julia projects with Pluto notebooks
task docs:serve   # For live-reload documentation server
```

### Environment Management

```bash
# Set up development environment from scratch
task setup

# Show package/dependency status
task pkg:status
task status

# Project overview and environment information
task info
```

### Code Quality

```bash
# Linting
task lint

# Formatting
task format

# Combined quality checks
task quality
```

## Using Task vs Direct Commands

### When to Use Task

Use `task` commands when:
- A Taskfile exists in the project
- You need to run standard development operations
- You want to discover available workflows
- You need consistency across team members

### When Task Wraps Underlying Commands

Tasks are typically thin wrappers around language-specific commands:

**Example - Julia:**
```bash
# Task command
task test

# Underlying command it runs
julia --project=. -e 'using Pkg; Pkg.test()'
```

**Example - R:**
```bash
# Task command
task docs

# Underlying command it runs
Rscript -e "devtools::document()"
```

### When to Use Direct Commands

Use direct language commands when:
- No Taskfile exists
- You need advanced options not exposed by tasks
- You're doing exploratory work outside standard workflows
- Tasks don't cover your specific use case

## Task Workflow Examples

### Typical Development Cycle

```bash
# 1. Discover what's available
task --list

# 2. Run fast iteration cycle
task dev          # Fast tests + fast docs

# 3. Before committing
task precommit    # Pre-commit checks + tests

# 4. Before pushing (optional)
task ci           # Full CI simulation
```

### First-Time Setup

```bash
# 1. See what setup tasks exist
task --list | grep setup

# 2. Run setup
task setup        # Install dependencies, configure environment

# 3. Verify setup
task info         # Show project and environment status

# 4. Test everything works
task test
```

## Task Naming Conventions

Common patterns in t