Automations

baseBranch === "main"
&& !draft
&& author.type !== "bot"

Review this pull request thoroughly:

1. Check for security vulnerabilities
2. Verify test coverage for new code
3. Look for potential bugs or edge cases
4. Suggest improvements to code quality
5. Verify documentation is updated

Leave specific inline comments on lines that need attention.
Approve if everything looks good, otherwise request changes.

PR: {{pr.url}}
Files changed: {{pr.files}}

check.name.includes("test")
&& branch !== "main"
&& branch !== "master"

The CI build failed on this commit:

Commit: {{commit.sha}}
Branch: {{branch}}
Check: {{check.name}}

Steps:
1. Analyze the failure logs
2. Identify the root cause
3. Fix the failing tests or code
4. Run tests locally to verify
5. Commit and push the fix
6. Comment on the commit with a summary

Logs:
{{check.output}}

labels.includes("bug")
&& !labels.includes("triaged")

Triage this bug report:

Issue: {{issue.title}}
Description: {{issue.body}}

1. Verify it's a valid bug (not feature request or question)
2. Determine severity: critical, high, medium, low
3. Identify affected component/module
4. Check for duplicates
5. Add appropriate labels
6. If you can reproduce it, attempt a fix
7. Leave a comment with your analysis

Add labels based on findings and mark as "triaged" when done.

Update project dependencies:

1. Run dependency update tool (npm update, yarn upgrade, etc.)
2. Update to latest compatible versions
3. Run full test suite after each major update
4. Fix any breaking changes
5. Update lockfiles
6. Create a PR with changes
7. Include changelog in PR description

Be conservative - prefer patch and minor updates over major.
If tests fail, roll back that dependency and note in PR.

files.some(f => f.startsWith("src/") || f.startsWith("lib/"))
&& !message.includes("[skip docs]")

Code was pushed to main. Update documentation if needed:

Commit: {{commit.message}}
Files: {{files}}

1. Review changed code files
2. Check if corresponding documentation exists
3. Update docs to reflect code changes
4. Update API references if public APIs changed
5. Fix any broken links
6. Commit doc changes to a new branch
7. Create PR linking back to the original commit

Only update docs if code changes affect public interfaces or behavior.

// Multiple labels required
labels.includes("bug") && labels.includes("p0")

// Title matching
title.toLowerCase().includes("security") ||
title.includes("[URGENT]")

// File-based triggers
files.some(f => f.endsWith(".sql")) &&
files.length < 5

// Author restrictions
author.username !== "dependabot" &&
author.type !== "Bot"

// Size limits
additions + deletions < 500

// Time-based (using helper)
isBusinessHours() && !isWeekend()

# GitHub PR
{{pr.title}}
{{pr.body}}
{{pr.url}}
{{pr.number}}
{{pr.files}}
{{pr.author.username}}
{{pr.baseBranch}}
{{pr.headBranch}}

# GitHub Issue
{{issue.title}}
{{issue.body}}
{{issue.number}}
{{issue.labels}}
{{issue.assignees}}
{{issue.author.username}}

# Linear Issue
{{linear.title}}
{{linear.description}}
{{linear.state}}
{{linear.team}}
{{linear.url}}

# Commit
{{commit.sha}}
{{commit.message}}
{{commit.author}}
{{commit.files}}

At the end of your task, create a GitHub issue titled
"Follow-up: {{task.description}}" with label "automated-follow-up".

This will trigger the next automation in the chain.