Generate Taskfiles Command

Instantly create complete Task automation setup for Go projects including main Taskfile, development tasks, and pre-commit hooks configuration. This command provides a comprehensive task runner setup with linting, testing, building, and release automation.

Why This Command Exists

Problem: Setting up task automation for Go projects requires manually creating Taskfile configuration, understanding Task syntax, and configuring pre-commit hooks - a 20-30 minute process.

Solution: One-command generation that:

• Creates complete Taskfile setup (3 files, 105 lines total)
• Includes tasks: lint, test, build, snapshot, release, image, doc
• Configures pre-commit hooks for automated quality checks
• Integrates with golangci-lint and goreleaser
• Provides development-specific tasks (pre-commit installation)

Content Generation Rules

CRITICAL: When generating any content (taskfiles, commit messages, or any other output):

• NEVER add Claude Code attribution or co-authorship
• NEVER include phrases like "Generated by Claude", "Created with Claude Code", or similar
• NEVER add "Co-Authored-By: Claude" in commit messages or documentation
• All generated content should appear as if written by a human developer
• Focus on technical accuracy and providing working templates

Process (6 Phases)

Phase 1: Prerequisites Validation

Critical checks before proceeding:

1. Validate Git repository:

   git rev-parse --git-dir
   

   • If fails: Exit with error "Not a git repository. Run 'git init' first."

2. Validate Go project:

   test -f go.mod
   

   • If fails: Exit with error "go.mod not found. This command is for Go projects only."

3. Check existing taskfiles:

   test -f Taskfile.yml
   test -f Taskfile_dev.yml
   test -f .pre-commit-config.yaml
   

   • Store which files exist: existingFiles = []
   • If any exist: Store hasExistingFiles = true

4. Verify command assets directory:

   • Use Read tool to verify ${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/Taskfile.yml exists
   • If fails: Exit with error "Command assets directory not found at ${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/. Plugin may be corrupted. Reinstall the go-specialist plugin."

5. Check for supporting configs (non-blocking):

   test -f .golangci.yml
   test -f .goreleaser.yml
   

   • If .golangci.yml missing: Store linterMissing = true (warn in Phase 6)
   • If .goreleaser.yml missing: Store goreleaserMissing = true (warn in Phase 6)

Phase 2: Argument Parsing

Parse command arguments from $argument string:

Supported flags:

• --force: Skip confirmation for existing files
• --dry-run: Show preview without writing files

Parsing logic:

arguments = split($argument by space)
for each arg in arguments:
  if arg == "--force": set forceMode = true
  if arg == "--dry-run": set dryRunMode = true

Phase 3: Template Reading

Read all template files from command assets directory:

Files to read:

1. Taskfile.yml (66 lines)

   • Path: ${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/Taskfile.yml
   • Target: Taskfile.yml (project root)

2. Taskfile_dev.yml (14 lines)

   • Path: ${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/Taskfile_dev.yml
   • Target: Taskfile_dev.yml (project root)

3. .pre-commit-config.yaml (25 lines)

   • Path: ${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/.pre-commit-config.yaml
   • Target: .pre-commit-config.yaml (project root)

Template handling:

• Store content in memory for Phase 3.5 substitution
• All substitutions handled in Phase 3.5 (not inline)

Error handling:

• If any Read fails: Exit with error "Failed to read template file: {filename}. Plugin may be corrupted. Ensure ${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/ directory exists."

Phase 3.5: Auto-Detection & Substitution

Detection Function Library: Use the shared detection functions from ${CLAUDE_PLUGIN_ROOT}/commands/assets/detection-functions.md. Read that file to get all bash detection functions (detect_project_name, detect_git_owner, detect_main_dir, detect_registry, substitute_placeholders).

Detection Workflow:

1. Detect all values:

   PROJECT_NAME=$(detect_project_name)
   OWNER=$(detect_git_owner)
   REGISTRY=$(detect_registry)
   MAIN_DIR=$(detect_main_dir)
   

2. Handle missing critical values:

   • If PROJECT_NAME is empty: Use "app" as default
   • If OWNER is empty: Preserve [OWNER] placeholder
   • Non-critical values have sensible defaults

3. Substitute placeholders in Taskfile.yml template:

   taskfile_template=$(substitute_placeholders "$taskfile_template" \
       "$PROJECT_NAME" "$OWNER" "$REGISTRY" "$MAIN_DIR")
   

4. Detect pre-commit-hooks version:

   PRE_COMMIT_HOOKS_VERSION=$(detect_pre_commit_hooks_version)
   

   • If empty (gh not available or API failure): Use fallback v4.3.0

5. Substitute version placeholders in .pre-commit-config.yaml template:

   precommit_template=$(substitute_version_placeholders "$precommit_template" \
       "PRE_COMMIT_HOOKS_VERSION=${PRE_COMMIT_HOOKS_VERSION:-v4.3.0}")
   

   Note: Taskfile_dev.yml has no placeholders

Phase 4: User Confirmation

Build preview summary:

Files to be created:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
✅ Taskfile.yml (66 lines) - Main task definitions
✅ Taskfile_dev.yml (14 lines) - Development tasks
✅ .pre-commit-config.yaml (25 lines) - Git pre-commit hooks

Total: 3 files (105 lines)

✅ Auto-detected Configuration
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Project Settings:
  • Project name: <PROJECT_NAME> (from go.mod)
  • Binary name: <PROJECT_NAME>
  • Main directory: <MAIN_DIR>

Repository Settings:
  • Owner: <OWNER> (from git remote)
  • Registry: <REGISTRY>

Task Categories:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🔧 Development:
   - default: List all available tasks
   - check-before-commit: Run all quality checks
   - lint: Run golangci-lint
   - test: Run unit tests with race detection
   - build: Build project binaries

📦 Release:
   - snapshot: Create snapshot release (goreleaser)
   - release: Create production release (goreleaser)
   - image: Build and push Docker image

📚 Documentation:
   - doc: Start godoc server

🛠️  Dev Tools (Taskfile_dev.yml):
   - dev:install-pre-commit: Install pre-commit hooks
   - dev:pre-commit: Run all pre-commit hooks manually

🎯 Pre-commit Hooks:
   - check-yaml: Validate YAML syntax
   - check-added-large-files: Prevent large files
   - unit-tests: Run tests before commit
   - lint: Run linter before commit
   - build: Test build before commit

[If hasExistingFiles == true:]
⚠️  WARNING: Some files already exist and will be overwritten:
[List existing files]

Dry run mode: If dryRunMode == true:

• Show preview summary above
• Display first 20 lines of each file
• Show customization requirements
• Display next steps guide
• Exit without creating files

Confirmation logic:

1. If --force flag provided: Skip confirmation, proceed to Phase 5

2. If existing files without --force:

   Use AskUserQuestion:
   Question: "Task configuration files already exist. Overwrite?"
   Options:
   1. "Yes, overwrite files" [Recommended if upgrading]
   2. "Show full preview first"
   3. "Cancel"
   
   If option 2: Display full content preview, then re-ask confirmation
   If option 3: Exit gracefully
   

3. If no existing files:

   Use AskUserQuestion:
   Question: "Create task configuration files (3 files)?"
   Options:
   1. "Yes, create files"
   2. "Show preview first"
   3. "Cancel"
   

Phase 5: File Creation

File writing sequence:

Write files in order:

1. Taskfile.yml

   • Replace BINFILE: gitlab-backup with detected binary name
   • Write to project root

2. Taskfile_dev.yml

   • Write as-is to project root

3. .pre-commit-config.yaml

   • Write as-is to project root

For each file:

• Use Write tool with full file path
• Write content from Phase 3 templates
• Track success/failure status
• Continue with remaining files if one fails (partial success acceptable)

Error handling:

• If individual file write fails: Log error, continue with next file
• If all writes fail: Report failure with details
• If partial success: Report which files succeeded/failed

Track results:

successfulFiles = []
failedFiles = []

for each file:
  try write:
    if success: add to successfulFiles
    if failure: add to failedFiles

Phase 6: Validation & Success Report

Post-creation validation:

For each file in successfulFiles:

1. Verify file exists
2. Verify non-zero size: File should be > 0 bytes
3. If validation fails: Move to failedFiles

Generate success report:

[If all files succeeded:]
✅ Task Configuration Created Successfully
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Created Files:
✅ Taskfile.yml (66 lines, ready to use)
✅ Taskfile_dev.yml (14 lines)
✅ .pre-commit-config.yaml (25 lines)

Total: 3 files (105 lines)

Auto-configured with detected values:
  ✓ Project name: <PROJECT_NAME> (from go.mod)
  ✓ Binary name: <PROJECT_NAME>
  ✓ Main directory: <MAIN_DIR> (auto-detected)
  ✓ Owner: <OWNER> (from git remote)
  ✓ Registry: <REGISTRY>
  ✓ Pre-commit hooks version: <PRE_COMMIT_HOOKS_VERSION>

Available Tasks:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Run `task` or `task -a` to see all available tasks.

Key Tasks:
- task check-before-commit  # Run all quality checks
- task lint                 # Run golangci-lint
- task test                 # Run unit tests with race detection
- task build                # Build binaries
- task snapshot             # Create test release
- task release              # Create production release
- task doc                  # Start godoc server
- task dev:install-pre-commit  # Install pre-commit hooks
- task dev:pre-commit       # Run pre-commit hooks manually

Required Dependencies:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️  Install these tools for full functionality:

1. Task (if not installed):
   - macOS: brew install go-task
   - Linux: sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b /usr/local/bin
   - Or: go install github.com/go-task/task/v3/cmd/task@latest

2. pre-commit (for git hooks):
   - macOS: brew install pre-commit
   - Linux: pip install pre-commit
   - After install: task dev:install-pre-commit

3. golangci-lint (for linting):
   [If linterMissing == true:]
   ⚠️  .golangci.yml not found
   - Generate with: /linter
   - Or install: https://golangci-lint.run/usage/install/

4. goreleaser (for releases):
   [If goreleaserMissing == true:]
   ⚠️  .goreleaser.yml not found
   - Generate with: /goreleaser
   - Or install: https://goreleaser.com/install/

Optional Customizations:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📝 Configuration is ready to use! Optional adjustments:

1. Multi-binary projects:
   - If your project has multiple binaries, update the build task
   - Example: Add separate build commands for each binary

2. Pre-commit hooks (.pre-commit-config.yaml):
   - Uncomment trailing-whitespace and end-of-file-fixer if desired
   - Customize which checks run before commits

3. Docker image settings (already auto-configured):
   - Verify registry and image name match your preferences
   - Auto-detected: <REGISTRY>/<OWNER>/<PROJECT_NAME>:latest

Pre-commit Hook Setup:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
To enable automatic quality checks on every commit:

1. Install pre-commit tool (see above)
2. Install hooks:
   task dev:install-pre-commit

3. Test hooks:
   task dev:pre-commit

4. Hooks will now run automatically on `git commit`
   - Checks YAML syntax
   - Prevents large files
   - Runs unit tests
   - Runs linter
   - Runs snapshot build

To bypass hooks (emergency only):
   git commit --no-verify -m "message"

Task Integration:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Tasks integrate with your development workflow:

- CI/CD pipelines can call: task lint, task test, task snapshot
- Pre-commit hooks run: task test, task lint, task snapshot
- Local development: task build, task doc
- Releases: task release (with git tags)

Next Steps:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Install Task runner (if not installed)
2. Review and customize Taskfile.yml
3. Install pre-commit: task dev:install-pre-commit
4. Generate missing configs:
   - .golangci.yml: /linter
   - .goreleaser.yml: /goreleaser

5. Test tasks:
   task lint
   task test
   task build

6. Commit changes:
   git add Taskfile*.yml .pre-commit-config.yaml
   git commit -m "build: add task automation and pre-commit hooks"

7. Verify pre-commit hooks:
   - Make a test change
   - Run: git commit
   - Hooks should run automatically

Documentation:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Task documentation: https://taskfile.dev
- Pre-commit documentation: https://pre-commit.com
- Task reference: Run `task -a` to list all tasks

[If partial success:]
⚠️  Task Configuration Partially Created
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Successfully Created:
[List successful files]

Failed to Create:
[List failed files with error messages]

Recommendation: Review errors and retry with --force flag

[If all files failed:]
❌ Task Configuration Creation Failed
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Errors:
[List all failures with details]

Possible causes:
- Insufficient permissions
- Disk space issues
- File system restrictions

Action: Check errors above and ensure write permissions in current directory

Command Arguments

Arguments are parsed from the argument string parameter:

• --force: Skip confirmation prompt and overwrite existing files

  • Use when: Upgrading existing task configuration
  • Behavior: Overwrites files directly without confirmation

• --dry-run: Preview files without writing to disk

  • Shows: File list, line counts, preview of content
  • Writes: Nothing
  • Use when: Reviewing what will be created before committing

Parsing example:

argument = "--force"
Split by space, check for each flag:
- forceMode = true
- dryRunMode = false

Error Handling

Critical Errors (Exit Immediately)

Not a Git repository:

❌ Error: Not a git repository

This command requires a Git repository. Initialize one:
  git init
  git add .
  git commit -m "Initial commit"

Not a Go project:

❌ Error: go.mod not found

This command is for Go projects only. Initialize a Go module:
  go mod init github.com/username/project

Command assets missing:

❌ Error: Command assets directory not found

The go-specialist plugin may be corrupted. Try:
1. Reinstalling the plugin
2. Updating Claude Code to latest version
3. Reporting issue at: https://github.com/sgaunet/claude-plugins/issues

Warning Errors (Continue with Warnings)

Existing task files:

• Without --force: Request user confirmation
• With --force: Overwrite silently

Missing .golangci.yml or .goreleaser.yml:

• Don't block creation
• Warn in success report
• Suggest using /linter or /goreleaser skills

Recovery Actions

If file write fails:

❌ Error: Failed to write [filename]

Check:
1. Current directory is writable
2. Sufficient disk space
3. No file system restrictions

Current permissions: [show with ls -ld .]

File Mapping

Source Path	Target (Relative to CWD)	Lines	Purpose
${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/Taskfile.yml	Taskfile.yml	66	Main task definitions
${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/Taskfile_dev.yml	Taskfile_dev.yml	14	Development tasks
${CLAUDE_PLUGIN_ROOT}/commands/assets/taskfiles/.pre-commit-config.yaml	.pre-commit-config.yaml	25	Git pre-commit hooks

Integration with Other Commands

Works with:

• /commit: Commit generated taskfiles
• /linter: Generate .golangci.yml (required for lint task)
• /goreleaser: Generate .goreleaser.yml (required for snapshot/release tasks)
• /gen-github-dir: GitHub workflows can call task commands
• /gen-gitlab-ci: GitLab CI can call task commands

Typical Workflow:

# 1. Generate task configuration
/gen-taskfiles

# 2. Generate supporting configs
/linter          # Creates .golangci.yml
/goreleaser      # Creates .goreleaser.yml

# 3. Install tools and hooks
brew install go-task pre-commit golangci-lint goreleaser
task dev:install-pre-commit

# 4. Test tasks
task lint
task test
task build

# 5. Commit everything
git add Taskfile*.yml .pre-commit-config.yaml .golangci.yml .goreleaser.yml
git commit -m "build: add task automation and pre-commit hooks"

# 6. Verify hooks work
# Make a test change, try to commit - hooks should run

Task Descriptions

Main Tasks (Taskfile.yml)

default: List all available tasks

• Dependencies: Checks for pre-commit hooks installed
• Command: task -a

check-before-commit: Run complete quality check suite

• Dependencies: test, snapshot, lint (in order)
• Use: Before pushing code or creating PR

lint: Run golangci-lint

• Command: golangci-lint run
• Requirements: .golangci.yml file

test: Run unit tests with race detection

• Command: go test -count=2 -race ./...
• Runs tests twice to catch flaky tests
• Race detector finds concurrency issues

build: Build project binaries

• Command: CGO-disabled builds for static binaries
• Customize: Update for your binary names

image: Build and push Docker image

• Dependencies: build task
• Customize: Update registry and image name

doc: Start godoc documentation server

• Command: godoc -http=:6060
• Access: http://localhost:6060

snapshot: Create snapshot release

• Command: goreleaser --clean --snapshot
• Requirements: .goreleaser.yml file
• Use: Test release process without publishing

release: Create production release

• Command: goreleaser --clean
• Requirements: .goreleaser.yml file, git tag
• Use: On tagged commits to publish release

Development Tasks (Taskfile_dev.yml)

dev:install-pre-commit: Install pre-commit hooks

• Command: pre-commit install
• Run once: After cloning repository

dev:pre-commit: Run all pre-commit hooks manually

• Command: pre-commit run --all-files
• Use: Test hooks before committing

Pre-commit Hooks Configuration

.pre-commit-config.yaml configures automatic quality checks:

Standard hooks (from pre-commit/pre-commit-hooks):

• check-yaml: Validate YAML syntax (enabled)
• check-added-large-files: Prevent commits of large files (enabled)
• trailing-whitespace: Remove trailing whitespace (commented, can enable)
• end-of-file-fixer: Ensure files end with newline (commented, can enable)

Local hooks (run task commands):

• unit-tests: Run task test before commit
• lint: Run task lint before commit
• build: Run task snapshot before commit

All local hooks use pass_filenames: false to run full checks, not per-file.

Best Practices

Before running command:

1. Ensure git repository initialized
2. Have go.mod configured
3. Review task documentation: https://taskfile.dev

After generation:

1. Review and customize Taskfile.yml
2. Generate .golangci.yml and .goreleaser.yml if missing
3. Install Task runner if not already installed
4. Install pre-commit: task dev:install-pre-commit
5. Test all tasks: task lint, task test, task build
6. Commit with meaningful message

Ongoing usage:

1. Run task check-before-commit before pushing code
2. Let pre-commit hooks catch issues automatically
3. Use task snapshot to test releases locally
4. Keep Task and pre-commit tools updated
5. Add custom tasks as project needs evolve

Limitations

This command does NOT:

• Generate .golangci.yml (use /linter command)
• Generate .goreleaser.yml (use /goreleaser command)
• Install Task runner or pre-commit tools (manual installation required)
• Modify existing taskfiles intelligently (use --force to overwrite)
• Install pre-commit hooks automatically (run task dev:install-pre-commit)
• Customize binary names automatically (detects from go.mod, may need manual adjustment)

Scope boundaries:

• Only handles task and pre-commit configuration files
• Templates are opinionated (aligned with gitlab-backup project patterns)
• Assumes standard Go project structure
• Requires manual customization for multi-binary projects
• Docker image task requires customization for your registry

Success Criteria

✅ Prerequisites validated (git repo, Go project) ✅ Template files read from skill assets (3 files) ✅ Binary name detected from go.mod ✅ User confirmation obtained (unless --force) ✅ All files written successfully (or partial success reported) ✅ Files validated (exist and non-zero size) ✅ Comprehensive success report displayed ✅ Customization instructions provided ✅ Next steps guide shown ✅ No Claude Code attribution in generated content ✅ Total runtime < 5 seconds

Examples

# Standard generation (3 files)
/gen-taskfiles

# Preview before creating
/gen-taskfiles --dry-run

# Overwrite existing configuration
/gen-taskfiles --force

# Force with dry run
/gen-taskfiles --force --dry-run

Output Summary

Standard mode (default):

• 3 files created
• 105 total lines
• Complete task automation setup with pre-commit hooks

Dry run mode (--dry-run):

• 0 files created
• Preview shown
• Safe exploration

Task vs Make

Why Task instead of Make?

• YAML syntax (easier than Makefile)
• Cross-platform (Windows, macOS, Linux)
• Built-in parallel execution
• Better dependency management
• Includes from other taskfiles
• Modern tool designed for development workflows

Migration from Make: If you have a Makefile, you can:

1. Keep both (Task can call make targets)
2. Gradually migrate targets to Taskfile.yml
3. Use Task as the primary interface, delegate to make when needed