dev-workflow

Original source / Raw SKILL.md

---
name: dev-workflow
description: Use when setting up or optimizing developer workflows in a monorepo, managing mise tasks, git hooks, CI/CD pipelines, database migrations, or release automation. Invoke for development environment setup, build automation, testing workflows, and release coordination.
---

# Dev Workflow

Dev workflow specialist for monorepo task automation and developer productivity.

## Role Definition

You are a senior DevOps engineer with 7+ years of experience in monorepo tooling and task automation. You specialize in mise (formerly rtx) task runner, parallel execution strategies, and multi-language development workflows. You excel at orchestrating complex build pipelines, managing cross-app dependencies, and optimizing development workflows for teams working with diverse technology stacks in a unified codebase.

## When to Use This Skill

- Running development servers for monorepo with multiple applications
- Executing lint, format, typecheck across multiple apps in parallel
- Managing database migrations and schema changes
- Generating API clients or code from schemas
- Building internationalization (i18n) files
- Executing production builds and deployment preparation
- Running parallel tasks in monorepo context
- Setting up pre-commit validation workflows
- Troubleshooting mise task failures or configuration issues
- Optimizing CI/CD pipelines with mise

## Core Workflow

1. **Analyze Task Requirements** - Identify which apps are affected and task dependencies
2. **Check mise Configuration** - Verify mise.toml structure and available tasks
3. **Determine Execution Strategy** - Decide between parallel vs sequential task execution
4. **Run Prerequisites** - Install runtimes, dependencies if needed
5. **Execute Tasks** - Run mise tasks with proper error handling
6. **Verify Results** - Check output, logs, and generated artifacts
7. **Report Status** - Summarize success/failure with actionable next steps

## Technical Guidelines

### Prerequisites

```bash
# Install mise
curl https://mise.run | sh

# Activate in shell
echo 'eval "$(~/.local/bin/mise activate)"' >> ~/.zshrc

# Install all runtimes defined in mise.toml
mise install

# Verify installation
mise list
```

### Project Structure (Monorepo)

```
project-root/
├── mise.toml            # Root task definitions
├── apps/
│   ├── api/            # Backend application
│   │   └── mise.toml   # App-specific tasks
│   ├── web/            # Frontend application
│   │   └── mise.toml
│   └── mobile/         # Mobile application
│       └── mise.toml
├── packages/
│   ├── shared/         # Shared libraries
│   └── config/         # Shared configuration
└── scripts/            # Utility scripts
```

### Task Syntax

**Root-level tasks:**
```bash
mise run lint        # Lint all apps (parallel)
mise run test        # Test all apps (parallel)
mise run dev         # Start all dev servers
mise run build       # Production builds
```

**App-specific tasks:**
```bash
# Syntax: mise run //{path}:{task}
mise run //apps/api:dev
mise run //apps/api:test
mise run //apps/web:build
```

### Common Task Patterns

| Task Type | Purpose | Example |
|-----------|---------|---------|
| `dev` | Start development server | `mise run //apps/api:dev` |
| `build` | Production build | `mise run //apps/web:build` |
| `test` | Run test suite | `mise run //apps/api:test` |
| `lint` | Run linter | `mise run lint` |
| `format` | Format code | `mise run format` |
| `typecheck` | Type checking | `mise run typecheck` |
| `migrate` | Database migrations | `mise run //apps/api:migrate` |

### Reference Guide

| Topic | Resource File | When to Load |
|-------|---------------|--------------|
| Validation Pipeline | `resources/validation-pipeline.md` | Git hooks, CI/CD, change-based testing |
| Database & Infrastructure | `resources/database-patterns.md` | Migrations, local Docker infra |
| API Generation | `resources/api-workflows.md` | Generating API clients |
| i18n Patterns | `resources/i18n-patterns.md` | Internationalization |
| Release Coordination | `resources/release-coordination.md` | Versioning, changelog, releases |
| Troubleshooting | `resources/troubleshooting.md` | Debugging issues |

### Task Dependencies

Define dependencies in `mise.toml`:

```toml
[tasks.build]
depends = ["lint", "test"]
run = "echo 'Building after lint and test pass'"

[tasks.dev]
depends = ["//apps/api:dev", "//apps/web:dev"]
```

### Parallel vs Sequential Execution

**Parallel (independent tasks):**
```bash
# Runs all lint tasks simultaneously
mise run lint
```

**Sequential (dependent tasks):**
```bash
# Runs in order: lint → test → build
mise run lint && mise run test && mise run build
```

**Mixed approach:**
```bash
# Start dev servers in background
mise run //apps/api:dev &
mise run //apps/web:dev &
wait
```

### Environment Variables

Common patterns for monorepo env vars:

```bash
# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/db

# Cache
REDIS_URL=redis://localhost:6379/0

# API
API_URL=http://localhost:8000

# Frontend
PUBLIC_API_URL=http://localhost:8000
```

## Constraints

### MUST DO
- Always use `mise run` tasks instead of direct package manager commands
- Run `mise install` after pulling changes that might update runtime versions
- Use parallel tasks (`mise run lint`, `mise run test`) for independent operations
- Run lint/test only on apps with changed files (`lint:changed`, `test:changed`)
- Validate commit messages with commitlint before committing
- Run pre-commit validation pipeline for staged files only
- Configure CI to skip unchanged apps for faster builds
- Check `mise tasks --all` to discover available tasks before running
- Verify task output and exit codes for CI/CD integration
- Document task dependencies in mise.toml comments
- Use consistent task naming conventions across apps
- Enable mise in CI/CD pipelines for reproducible builds
- Pin runtime versions in mise.toml for consistency
- Test tasks locally before committing CI/CD changes

### MUST NOT DO
- Never use direct package manager commands when mise tasks exist
- Never modify mise.toml without understanding task dependencies
- Never skip `mise install` after toolchain version updates
- Never run dev servers without checking port availability first
- Never commit without running validation on affected apps
- Never ignore task failures - always investigate root cause
- Never hardcode secrets in mise.toml files
- Never assume task availability - always verify with `mise tasks`
- Never run destructive tasks (clean, reset) without confirmation
- Never skip reading task definitions before running unfamiliar tasks

## Output Templates

When setting up development environment:
1. Runtime installation verification (`mise list`)
2. Dependency installation commands per app
3. Environment variable template (.env.example)
4. Development server startup commands
5. Common task quick reference

When running tasks:
1. Command executed with full path
2. Expected output summary
3. Duration and success/failure status
4. Next recommended actions

When troubleshooting:
1. Diagnostic commands (`mise config`, `mise doctor`)
2. Common issue solutions
3. Port/process conflict resolution
4. Cleanup commands if needed

## Troubleshooting Guide

| Issue | Solution |
|-------|----------|
| Task not found | Run `mise tasks --all` to list available tasks |
| Runtime not found | Run `mise install` to install missing runtime |
| Task hangs | Check for interactive prompts, use `--yes` if available |
| Port already in use | Find process: `lsof -ti:PORT` then kill |
| Permission denied | Check file permissions, try with proper user |
| Missing dependencies | Run `mise run install` or app-specific install |

## Knowledge Reference

mise, task runner, monorepo, dev server, lint, format, test, typecheck, build, deployment, ci/cd, parallel execution, workflow, automation, tooling


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### resources/validation-pipeline.md

```markdown
# Validation Pipeline

Complete validation pipeline with local git hooks and CI/CD integration.

## Commitlint Configuration

```json
// commitlint.config.js
module.exports = {
  extends: ['@commitlint/config-conventional'],
  rules: {
    'type-enum': [
      2,
      'always',
      ['feat', 'fix', 'docs', 'style', 'refactor', 'test', 'chore', 'ci', 'infra']
    ],
    'scope-enum': [
      2,
      'always',
      ['web', 'api', 'mobile', 'worker', 'shared', 'infra', 'deps']
    ]
  }
};
```

## Local Validation (Git Hooks)

### Mise Hooks Setup

```toml
# mise.toml
[hooks]
postinstall = '''
  mkdir -p .git/hooks

  # commit-msg hook
  cat > .git/hooks/commit-msg <<'EOF'
#!/bin/sh
exec mise run git:commit-msg -- "$1"
EOF
  chmod +x .git/hooks/commit-msg

  # pre-commit hook
  cat > .git/hooks/pre-commit <<'EOF'
#!/bin/sh
exec mise run git:pre-commit
EOF
  chmod +x .git/hooks/pre-commit

  # pre-push hook
  cat > .git/hooks/pre-push <<'EOF'
#!/bin/sh
exec mise run git:pre-push
EOF
  chmod +x .git/hooks/pre-push
'''
```

### Git Hook Tasks

```toml
[tasks."git:commit-msg"]
description = "Validate commit message using commitlint"
run = "bunx @commitlint/cli@20 --edit $1"

[tasks."git:pre-commit"]
description = "Run lint on changed files"
run = '''
#!/usr/bin/env bash
changed=$(git diff --cached --name-only)

if echo "$changed" | grep -q "^apps/api/"; then
    echo "[pre-commit] apps/api detected, running lint..."
    mise //apps/api:lint || exit 1
fi

if echo "$changed" | grep -q "^apps/web/"; then
    echo "[pre-commit] apps/web detected, running lint..."
    mise //apps/web:lint || exit 1
fi

if echo "$changed" | grep -q "^apps/mobile/"; then
    echo "[pre-commit] apps/mobile detected, running lint..."
    mise //apps/mobile:lint || exit 1
fi
'''

[tasks."git:pre-push"]
description = "Validate branch name and run tests"
run = '''
#!/usr/bin/env bash
# Validate branch name
bunx @gracefullight/validate-branch || exit 1

# Get changed files
changed=$(git diff --name-only origin/main...HEAD 2>/dev/null || git diff --name-only HEAD~1)

if echo "$changed" | grep -q "^apps/api/"; then
    echo "[pre-push] apps/api detected, running test..."
    mise //apps/api:test || exit 1
fi

if echo "$changed" | grep -q "^apps/web/"; then
    echo "[pre-push] apps/web detected, running test..."
    mise //apps/web:test || exit 1
fi

if echo "$changed" | grep -q "^apps/mobile/"; then
    echo "[pre-push] apps/mobile detected, running test..."
    mise //apps/mobile:test || exit 1
fi
'''
```

## CI/CD Validation (GitHub Actions)

### Full Workflow

```yaml
# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: jdx/mise-action@v2
      - run: mise run install
      - run: mise run lint
      - run: mise run typecheck
      - run: mise run test
```

### Change-Based Workflow

```yaml
# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      web: ${{ steps.changes.outputs.web }}
      api: ${{ steps.changes.outputs.api }}
      mobile: ${{ steps.changes.outputs.mobile }}
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: changes
        with:
          filters: |
            web:
              - 'apps/web/**'
            api:
              - 'apps/api/**'
            mobile:
              - 'apps/mobile/**'

  lint-web:
    needs: detect-changes
    if: ${{ needs.detect-changes.outputs.web == 'true' }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: jdx/mise-action@v2
      - run: mise run //apps/web:lint

  lint-api:
    needs: detect-changes
    if: ${{ needs.detect-changes.outputs.api == 'true' }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: jdx/mise-action@v2
      - run: mise run //apps/api:lint

  test-web:
    needs: [detect-changes, lint-web]
    if: ${{ needs.detect-changes.outputs.web == 'true' }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: jdx/mise-action@v2
      - run: mise run //apps/web:test
```

## Reusable Tasks

```toml
# Root mise.toml
[tasks.lint:changed]
description = "Lint only changed apps"
run = '''
#!/usr/bin/env bash
changed_files=$(git diff --name-only HEAD~1)

if echo "$changed_files" | grep -q "^apps/web/"; then
  echo "→ Linting web..."
  mise run //apps/web:lint || exit 1
fi

if echo "$changed_files" | grep -q "^apps/api/"; then
  echo "→ Linting api..."
  mise run //apps/api:lint || exit 1
fi

if echo "$changed_files" | grep -q "^apps/mobile/"; then
  echo "→ Linting mobile..."
  mise run //apps/mobile:lint || exit 1
fi
'''

[tasks.test:changed]
description = "Test only changed apps"
run = '''
#!/usr/bin/env bash
changed_files=$(git diff --name-only HEAD~1)

if echo "$changed_files" | grep -q "^apps/web/"; then
  echo "→ Testing web..."
  mise run //apps/web:test || exit 1
fi

if echo "$changed_files" | grep -q "^apps/api/"; then
  echo "→ Testing api..."
  mise run //apps/api:test || exit 1
fi

if echo "$changed_files" | grep -q "^apps/mobile/"; then
  echo "→ Testing mobile..."
  mise run //apps/mobile:test || exit 1
fi
'''

[tasks.validate:changed]
description = "Validate only changed apps"
depends = ["lint:changed", "test:changed"]
```

## Complete Root mise.toml Example

```toml
[tools]
node = "24"
python = "3.12"
flutter = "3"
bun = "latest"

[hooks]
postinstall = '''
  mkdir -p .git/hooks

  cat > .git/hooks/commit-msg <<'EOF'
#!/bin/sh
exec mise run git:commit-msg -- "$1"
EOF
  chmod +x .git/hooks/commit-msg

  cat > .git/hooks/pre-commit <<'EOF'
#!/bin/sh
exec mise run git:pre-commit
EOF
  chmod +x .git/hooks/pre-commit

  cat > .git/hooks/pre-push <<'EOF'
#!/bin/sh
exec mise run git:pre-push
EOF
  chmod +x .git/hooks/pre-push
'''

[tasks.dev]
description = "Start all development services"
depends = ["//apps/api:dev", "//apps/web:dev"]

[tasks.lint]
description = "Lint all apps"
depends = ["//apps/api:lint", "//apps/web:lint", "//apps/mobile:lint"]

[tasks.test]
description = "Test all apps"
depends = ["//apps/api:test", "//apps/web:test", "//apps/mobile:test"]

[tasks."git:commit-msg"]
description = "Validate commit message"
run = "bunx @commitlint/cli@20 --edit $1"

[tasks."git:pre-commit"]
description = "Run lint on changed files"
run = '''
#!/usr/bin/env bash
changed=$(git diff --cached --name-only)

if echo "$changed" | grep -q "^apps/web/"; then
    mise //apps/web:lint || exit 1
fi

if echo "$changed" | grep -q "^apps/api/"; then
    mise //apps/api:lint || exit 1
fi
'''

[tasks."git:pre-push"]
description = "Run tests + branch validation"
run = '''
#!/usr/bin/env bash
bunx @gracefullight/validate-branch || exit 1

changed=$(git diff --name-only origin/main...HEAD 2>/dev/null || git diff --name-only HEAD~1)

if echo "$changed" | grep -q "^apps/web/"; then
    mise //apps/web:test || exit 1
fi

if echo "$changed" | grep -q "^apps/api/"; then
    mise //apps/api:test || exit 1
fi
'''

[tasks.lint:changed]
description = "Lint only changed apps"
run = '''
#!/usr/bin/env bash
changed_files=$(git diff --name-only HEAD~1)

if echo "$changed_files" | grep -q "^apps/web/"; then
  mise run //apps/web:lint || exit 1
fi

if echo "$changed_files" | grep -q "^apps/api/"; then
  mise run //apps/api:lint || exit 1
fi
'''

[tasks.test:changed]
description = "Test only changed apps"
run = '''
#!/usr/bin/env bash
changed_files=$(git diff --name-only HEAD~1)

if echo "$changed_files" | grep -q "^apps/web/"; then
  mise run //apps/web:test || exit 1
fi

if echo "$changed_files" | grep -q "^apps/api/"; then
  mise run //apps/api:test || exit 1
fi
'''
```

```

### resources/database-patterns.md

```markdown
# Database & Local Infrastructure

Database migration workflows and local development infrastructure.

## Migration Tasks

```toml
# apps/api/mise.toml
[tasks.migrate]
description = "Run Alembic migrations"
run = "uv run alembic upgrade head"

[tasks.migrate:create]
description = "Create new migration"
run = "uv run alembic revision --autogenerate -m '{{arg(name)}}'"

[tasks.migrate:check]
description = "Check migration status"
run = "uv run alembic current"

[tasks.migrate:history]
description = "Show migration history"
run = "uv run alembic history --verbose"

[tasks.migrate:rollback]
description = "Rollback one migration"
run = "uv run alembic downgrade -1"

[tasks.migrate:reset]
description = "Reset database (all down then up)"
run = "uv run alembic downgrade base && uv run alembic upgrade head"
```

## Creating Migrations

```bash
# Create new migration
mise run //apps/api:migrate:create "add users table"

# Review generated migration
# Edit: apps/api/alembic/versions/xxx_add_users_table.py

# Apply migration
mise run //apps/api:migrate

# Check current version
mise run //apps/api:migrate:check

# View history
mise run //apps/api:migrate:history

# Rollback (if needed)
mise run //apps/api:migrate:rollback
```

## Root-Level Database Tasks

```toml
# Root mise.toml
[tasks.db:migrate]
description = "Run all database migrations"
depends = ["//apps/api:migrate"]

[tasks.db:reset]
description = "Reset all databases"
depends = ["//apps/api:migrate:reset"]
```

## Local Infrastructure (Docker)

```toml
# apps/api/mise.toml
[tasks.infra:up]
description = "Start local infrastructure (PostgreSQL, Redis, etc.)"
run = "docker compose -f docker-compose.infra.yml up -d"

[tasks.infra:down]
description = "Stop local infrastructure"
run = "docker compose -f docker-compose.infra.yml down"

[tasks.infra:logs]
description = "View infrastructure logs"
run = "docker compose -f docker-compose.infra.yml logs -f"

[tasks.infra:reset]
description = "Reset infrastructure (remove volumes)"
run = "docker compose -f docker-compose.infra.yml down -v"
```

## Root-Level Infrastructure Tasks

```toml
# Root mise.toml
[tasks.infra:up]
description = "Start all local infrastructure"
depends = ["//apps/api:infra:up"]

[tasks.infra:down]
description = "Stop all local infrastructure"
depends = ["//apps/api:infra:down"]
```

```

### resources/api-workflows.md

```markdown
# API Generation Workflows

Generate API clients from OpenAPI schemas.

## OpenAPI to Client Pipeline

```bash
# 1. Generate OpenAPI schema from backend
mise run //apps/api:gen:openapi

# 2. Generate TypeScript client for web
mise run //apps/web:gen:api

# 3. Generate Dart client for mobile
mise run //apps/mobile:gen:api
```

## Backend Tasks

```toml
# apps/api/mise.toml
[tasks.gen:openapi]
description = "Generate OpenAPI schema"
run = "uv run python -c 'from src.main import app; import json; print(json.dumps(app.openapi()))' > openapi.json"
```

## Web Tasks

```toml
# apps/web/mise.toml
[tasks.gen:api]
description = "Generate API client from OpenAPI"
depends = ["//apps/api:gen:openapi"]
run = "bunx orval"
```

## Mobile Tasks

```toml
# apps/mobile/mise.toml
[tasks.gen:api]
description = "Generate API client from OpenAPI"
depends = ["//apps/api:gen:openapi"]
run = "flutter pub run swagger_parser"
```

## Root-Level API Generation

```toml
# Root mise.toml
[tasks.gen:api]
description = "Generate API clients for all apps"
depends = [
  "//apps/api:gen:openapi",
  "//apps/web:gen:api",
  "//apps/mobile:gen:api"
]
```

```

### resources/i18n-patterns.md

```markdown
# i18n Build Patterns

Internationalization workflows for monorepos.

## Shared i18n Package

```toml
# packages/i18n/mise.toml
[tasks.build]
description = "Build i18n files for all platforms"
depends = ["build:web", "build:mobile"]

[tasks.build:web]
description = "Build for web (next-intl JSON)"
run = "bun scripts/build-web.js"

[tasks.build:mobile]
description = "Build for mobile (Flutter ARB)"
run = "bun scripts/build-mobile.js"

[tasks.watch]
description = "Watch for changes and rebuild"
run = "bun scripts/watch.js"
```

## Usage in Apps

```bash
# Build i18n for all apps
mise run //packages/i18n:build

# Watch for changes during development
mise run //packages/i18n:watch
```

## Web Integration

```toml
# apps/web/mise.toml
[tasks.dev]
description = "Start Next.js dev server"
depends = ["//packages/i18n:build"]
run = "bun dev"

[tasks.build]
description = "Production build"
depends = ["//packages/i18n:build"]
run = "bun run build"
```

## Mobile Integration

```toml
# apps/mobile/mise.toml
[tasks.gen:l10n]
description = "Generate Flutter localizations"
run = "flutter gen-l10n"

[tasks.dev]
description = "Run Flutter on device"
depends = ["gen:l10n"]
run = "flutter run"
```

```

### resources/release-coordination.md

```markdown
# Release Coordination

Release Please workflow for automated versioning and releases.

## Overview

This project uses Google's [Release Please](https://github.com/googleapis/release-please) for automated versioning and releases based on conventional commits.

## How It Works

1. **Release PR Creation**: When conventional commits are merged to main, Release Please creates a release PR
2. **CHANGELOG Generation**: Automatically generates CHANGELOG.md from commits
3. **Version Bumping**: Updates version in package.json and other files
4. **Release on Merge**: When the release PR is merged, a GitHub release is created

## GitHub Actions Workflow

```yaml
# .github/workflows/release-please.yml
name: Release Please

on:
  push:
    branches: [main]

permissions:
  contents: write
  pull-requests: write

jobs:
  release-please:
    runs-on: ubuntu-latest
    steps:
      - uses: google-github-actions/release-please-action@v4
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          release-type: node
          package-name: oh-my-agent
```

## Mise Tasks for Release Management

```toml
# Root mise.toml
[tools]
node = "24"
bun = "latest"

[tasks.release:check]
description = "Check release-please status"
run = '''
#!/usr/bin/env bash
echo "🔍 Checking release status..."
echo ""
echo "Open release PRs:"
bunx gh pr list --label "autorelease: pending" --state open
echo ""
echo "Latest releases:"
bunx gh release list --limit 5
'''

[tasks.release:manifest]
description = "Show current release manifest"
run = "cat .release-please-manifest.json"

[tasks.release:changelog]
description = "Preview changelog (local dry-run)"
run = '''
#!/usr/bin/env bash
echo "📋 Recent conventional commits:"
git log --pretty=format:"%s" $(git describe --tags --abbrev=0)..HEAD | grep -E "^(feat|fix|docs|style|refactor|test|chore|ci)(\(.+\))?:"
'''
```

## Conventional Commit Format

Release Please recognizes these commit types:

| Type | Version Bump | Description |
|------|--------------|-------------|
| `feat:` | minor | New feature |
| `fix:` | patch | Bug fix |
| `docs:` | patch | Documentation |
| `style:` | patch | Code style (no logic) |
| `refactor:` | patch | Code refactoring |
| `test:` | patch | Tests |
| `chore:` | patch | Maintenance |
| `feat!:` | major | Breaking change |
| `fix!:` | major | Breaking bug fix |

## Release Configuration

```json
// .release-please-config.json
{
  "packages": {
    ".": {
      "release-type": "node",
      "draft": false,
      "prerelease": false
    }
  }
}
```

```json
// .release-please-manifest.json
{
  ".": "1.0.0"
}
```

## Release Flow

### 1. Develop Features
```bash
# Make changes with conventional commits
git commit -m "feat(cli): add infrastructure skills category"
git commit -m "fix(cli): correct skill installation path"
git commit -m "docs: update installation guide"
```

### 2. Merge to Main
```bash
git push origin main
```

### 3. Release Please Creates PR
Automatically creates a PR like:
- Title: `chore(main): release 1.1.0`
- Includes updated CHANGELOG.md
- Includes version bump in package.json

### 4. Review and Merge
```bash
# Check the release PR
bunx gh pr list --label "autorelease: pending"

# Review changes
git fetch origin
git diff origin/main...release-please--branches--main

# Merge via GitHub (creates release)
```

### 5. Verify Release
```toml
[tasks.release:verify]
description = "Verify latest release"
run = '''
#!/usr/bin/env bash
echo "✅ Latest release:"
bunx gh release view --json tagName,name,createdAt

echo ""
echo "📦 Assets:"
bunx gh release view --json assets
'''
```

## Manual Release Trigger

If needed, manually trigger release-please:

```toml
[tasks.release:trigger]
description = "Manually trigger release-please (CI will handle)"
run = '''
#!/usr/bin/env bash
echo "🚀 Triggering release-please..."
echo "Push to main will trigger the workflow automatically"
echo ""
echo "Current status:"
mise run release:check
'''
```

## Post-Release Tasks

```toml
[tasks.release:cleanup]
description = "Cleanup after release"
run = '''
#!/usr/bin/env bash
echo "🧹 Post-release cleanup..."

# Pull latest changes with tags
git pull origin main --tags

# Verify local state
echo ""
echo "Local version:"
cat package.json | grep '"version"' | cut -d'"' -f4

echo ""
echo "Latest tag:"
git describe --tags --abbrev=0

echo ""
echo "✅ Release cleanup complete"
'''
```

## Troubleshooting

```toml
[tasks.release:debug]
description = "Debug release issues"
run = '''
#!/usr/bin/env bash
echo "🔍 Release Debugging"
echo ""

echo "1. Conventional commits since last tag:"
git log --pretty=format:"%s" $(git describe --tags --abbrev=0 2>/dev/null || echo "HEAD~10")..HEAD | grep -E "^(feat|fix|docs|style|refactor|test|chore|ci)(\(.+\))?:" || echo "  No conventional commits found"

echo ""
echo "2. Release Please config files:"
ls -la .release-please*.json 2>/dev/null || echo "  Config files not found"

echo ""
echo "3. GitHub Actions status:"
bunx gh run list --workflow=release-please.yml --limit 5 2>/dev/null || echo "  No runs found"

echo ""
echo "4. Open release PRs:"
bunx gh pr list --label "autorelease: pending" 2>/dev/null || echo "  No release PRs"
'''
```

## Setup Requirements

1. **GitHub Actions workflow** (`.github/workflows/release-please.yml`)
2. **Release Please config** (`.release-please-config.json`)
3. **Release Please manifest** (`.release-please-manifest.json`)
4. **Conventional commits** (already configured via commitlint)

## Benefits

- ✅ Automated versioning based on commits
- ✅ Auto-generated CHANGELOG.md
- ✅ GitHub releases with notes
- ✅ No manual version bumping
- ✅ Integrated with GitHub PR workflow

```

### resources/troubleshooting.md

```markdown
# Troubleshooting

Common issues and solutions.

## Task Not Found

```bash
# List all available tasks
mise tasks --all

# Show task details
mise tasks <task-name>
```

## Runtime Not Found

```bash
# Install all runtimes
mise install

# Install specific runtime
mise install node@24

# List installed runtimes
mise list
```

## Port Already in Use

```bash
# Check ports
lsof -ti:8000  # API port
lsof -ti:3000  # Web port
lsof -ti:8080  # Mobile port

# Kill processes
lsof -ti:8000 | xargs kill -9
```

## Task Hangs

```bash
# Run with verbose output
mise run dev --verbose

# Debug mode
MISE_DEBUG=1 mise run dev

# Check for interactive prompts (use --yes if available)
mise run install --yes
```

## Clean State

```bash
# Stop all dev servers
pkill -f "mise run"

# Clean mise cache
mise cache clear

# Reinstall everything
mise uninstall --all
mise install
```

## Debug Configuration

```bash
# Show mise config
mise config

# Show environment
mise env

# Doctor - check for issues
mise doctor
```

```