Skip to content

aiskillstore/marketplace / skills/0xdarkmatter/claude-code-headless

claude-code-headless

Verified

Run Claude Code programmatically without interactive UI. Triggers on: headless, CLI automation, --print, output-format, stream-json, CI/CD, scripting.

FileKindSize
SKILL.mdskill md3.2 KB
references/cli-options.mdmarkdown4.2 KB
references/integration-patterns.mdmarkdown8.3 KB
references/output-formats.mdmarkdown4.6 KB
skill-report.jsonconfig102.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'
}
```
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
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: 198kUpdated Claude CodeCodexVerifiedInstall
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: 119kUpdated Claude CodeCodexVerifiedInstall
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: 118kUpdated Claude CodeCodexVerifiedInstall