aiskillstore/marketplace / skills/0xdarkmatter/claude-code-headless
claude-code-headless
VerifiedRun Claude Code programmatically without interactive UI. Triggers on: headless, CLI automation, --print, output-format, stream-json, CI/CD, scripting.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 3.2 KB |
| references/cli-options.md | markdown | 4.2 KB |
| references/integration-patterns.md | markdown | 8.3 KB |
| references/output-formats.md | markdown | 4.6 KB |
| skill-report.json | config | 102.5 KB |
references/integration-patterns.md
View on GitHub# Integration Patterns
Patterns for integrating Claude Code into CI/CD, scripts, and automation.
## CI/CD Pipelines
### GitHub Actions
```yaml
name: Claude Code Review
on:
pull_request:
types: [opened, synchronize]
jobs:
review:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Get PR diff
id: diff
run: |
gh pr diff ${{ github.event.pull_request.number }} > diff.txt
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Run Claude review
run: |
result=$(cat diff.txt | claude -p "Review this PR diff for:
- Security vulnerabilities
- Performance issues
- Code quality
Output as markdown." \
--output-format json \
--allowedTools "Read,Grep")
echo "$result" | jq -r '.result' > review.md
env:
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
- name: Post review comment
run: |
gh pr comment ${{ github.event.pull_request.number }} \
--body-file review.md
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```
### GitLab CI
```yaml
claude-review:
stage: review
script:
- git diff origin/main...HEAD > diff.txt
- |
cat diff.txt | claude -p "Security review" \
--output-format json \
--allowedTools "Read" \
> review.json
- cat review.json | jq -r '.result' > review.md
artifacts:
paths:
- review.md
only:
- merge_requests
```
### Jenkins
```groovy
pipeline {
agent any
environment {
ANTHROPIC_API_KEY = credentials('anthropic-api-key')
}
stages {
stage('Claude Analysis') {
steps {
script {
def result = sh(
script: '''
claude -p "Analyze build issues" \
--output-format json \
--allowedTools "Read,Bash"
''',
returnStdout: true
)
def json = readJSON text: result
if (json.is_error) {
error "Claude analysis failed: ${json.result}"
}
}
}
}
}
}
```
## Shell Scripts
### PR Review Script
```bash
#!/bin/bash
set -euo pipefail
audit_pr() {
local pr_number="$1"
# Get PR diff
diff=$(gh pr diff "$pr_number")
# Run Claude analysis
result=$(echo "$diff" | claude -p \
--append-system-prompt "Security review. Output JSON: {severity, findings, recommendations}" \
--output-format json \
--allowedTools "Read,Grep,WebSearch")
# Check for errors
if [[ $(echo "$result" | jq -r '.is_error') == "true" ]]; then
echo "Error: $(echo "$result" | jq -r '.result')" >&2
return 1
fi
echo "$result" | jq -r '.result'
}
# Usage
audit_pr 123
```
### Batch Processing
```bash
#!/bin/bash
set -euo pipefail
process_files() {
local pattern="$1"
local prompt="$2"
find . -name "$pattern" -print0 | while IFS= read -r -d '' file; do
echo "Processing: $file"
result=$(cat "$file" | claude -p "$prompt" \
--output-format json \
--allowedTools "Read")
if [[ $(echo "$result" | jq -r '.is_error') == "false" ]]; then
echo "$result" | jq -r '.result' > "${file}.analysis.md"
fi
done
}
# Usage
process_files "*.py" "Analyze this Python file for issues"
```
### Multi-Turn Workflow
```bash
#!/bin/bash
set -euo pipefail
run_workflow() {
# Step 1: Initial analysis
result=$(claude -p "Analyze the codebase structure" \
--output-format json \
--allowedTools "Read,Glob,Grep")
session=$(echo "$result" | jq -r '.session_id')
echo "Session: $session"
# Step 2: Deep dive with context
result=$(claude --resume "$session" \
"Now examine the authentication module in detail" \
--output-format json)
# Step 3: Generate report
claude --resume "$session" \
"Generate a security report in markdown" \
--output-format json | jq -r '.result' > report.md
echo "Report saved to report.md"
}
run_workflow
```
## Pre-commit Hooks
### Python Code Review
```bash
#!/bin/bash
# .git/hooks/pre-commit
staged_files=$(git diff --cached --name-only --diff-filter=ACM | grep '\.py$' || true)
if [[ -n "$staged_files" ]]; then
echo "Running Claude review on staged Python files..."
for file in $staged_files; do
result=$(cat "$file" | claude -p \
"Quick code review. Report only critical issues. Be concise." \
--output-format json \
--allowedTools "Read" 2>/dev/null)
if [[ $(echo "$result" | jq -r '.is_error') == "false" ]]; then
review=$(echo "$result" | jq -r '.result')
if [[ "$review" != *"no issues"* ]] && [[ "$review" != *"looks good"* ]]; then
echo "Review for $file:"
echo "$review"
echo ""
fi
fi
done
fi
```
## Scheduled Tasks
### Daily Code Quality Report
```bash
#!/bin/bash
# Run via cron: 0 8 * * * /path/to/daily-report.sh
REPORT_DIR="/var/reports/claude"
DATE=$(date +%Y-%m-%d)
mkdir -p "$REPORT_DIR"
cd /path/to/project
result=$(claude -p "Generate a daily code quality report covering:
1. Recent changes summary
2. Potential issues
3. Recommendations
Use git log for recent changes." \
--output-format json \
--allowedTools "Bash,Read,Grep")
echo "$result" | jq -r '.result' > "$REPORT_DIR/report-$DATE.md"
# Email or Slack notification
# curl -X POST "$SLACK_WEBHOOK" -d "{\"text\": \"Daily report ready\"}"
```
## Web Application Integration
### Express.js Endpoint
```javascript
const express = require('express');
const { spawn } = require('child_process');
const app = express();
app.use(express.json());
app.post('/api/claude', async (req, res) => {
const { prompt, tools } = req.body;
const args = ['-p', prompt, '--output-format', 'json'];
if (tools) {
args.push('--allowedTools', tools.join(','));
}
const claude = spawn('claude', args);
let output = '';
claude.stdout.on('data', (data) => {
output += data.toString();
});
claude.on('close', (code) => {
try {
const result = JSON.parse(output);
res.json(result);
} catch (e) {
res.status(500).json({ error: 'Failed to parse response' });
}
});
});
app.listen(3000);
```
### Python FastAPI
```python
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import subprocess
import json
app = FastAPI()
class ClaudeRequest(BaseModel):
prompt: str
tools: list[str] | None = None
@app.post("/api/claude")
async def run_claude(request: ClaudeRequest):
args = ["claude", "-p", request.prompt, "--output-format", "json"]
if request.tools:
args.extend(["--allowedTools", ",".join(request.tools)])
proc = subprocess.run(args, capture_output=True, text=True)
try:
result = json.loads(proc.stdout)
return result
except json.JSONDecodeError:
raise HTTPException(status_code=500, detail="Failed to parse response")
```
## Error Handling Patterns
### Retry with Backoff
```bash
#!/bin/bash
run_with_retry() {
local max_attempts=3
local attempt=1
local delay=5
while [[ $attempt -le $max_attempts ]]; do
result=$(claude -p "$1" --output-format json 2>&1)
if [[ $(echo "$result" | jq -r '.is_error // true') == "false" ]]; then
echo "$result"
return 0
fi
echo "Attempt $attempt failed, retrying in ${delay}s..." >&2
sleep $delay
attempt=$((attempt + 1))
delay=$((delay * 2))
done
echo "All attempts failed" >&2
return 1
}
```
### Graceful Degradation
```bash
#!/bin/bash
analyze_with_fallback() {
# Try Claude first
result=$(claude -p "$1" --output-format json 2>/dev/null)
if [[ -z "$result" ]] || [[ $(echo "$result" | jq -r '.is_error') == "true" ]]; then
echo "Claude unavailable, using fallback analysis" >&2
# Fallback to simpler analysis
run_basic_linter "$2"
return
fi
echo "$result" | jq -r '.result'
}
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |