# Direct prompt
claude -p "Explain the authentication flow in this project"

# Piped input
cat error.log | claude -p "Diagnose the root cause of these errors"

# File content as context
claude -p "Review this code for security issues" < src/auth.py

claude -p "What does the main function do?" --output-format text

result=$(claude -p "Fix the type error in utils.ts" --output-format json)
echo "$result" | jq '.result'
echo "$result" | jq '.total_cost_usd'

system (init) → assistant/user messages (interleaved) → result (final)

claude -p "Refactor the database module" --output-format stream-json | while IFS= read -r line; do
  type=$(echo "$line" | jq -r '.type')
  case "$type" in
    system) echo "Session: $(echo "$line" | jq -r '.session_id')" ;;
    assistant) echo "$line" | jq -r '.message.content[]? | select(.type == "text") | .text' ;;
    result) echo "Cost: $(echo "$line" | jq -r '.total_cost_usd')" ;;
  esac
done

# Extract only text output from assistant messages
claude -p "query" --output-format stream-json \
  | jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "text") | .text'

# Extract tool usage
claude -p "query" --output-format stream-json \
  | jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | "\(.name): \(.input | tostring)"'

# Get final cost
claude -p "query" --output-format stream-json \
  | jq -r 'select(.type == "result") | "Cost: $\(.total_cost_usd) | Turns: \(.num_turns)"'

claude -p "Extract all API endpoints from this project" \
  --output-format json \
  --json-schema '{
    "type": "object",
    "properties": {
      "endpoints": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "method": {"type": "string"},
            "path": {"type": "string"},
            "description": {"type": "string"}
          },
          "required": ["method", "path"]
        }
      }
    },
    "required": ["endpoints"]
  }'

# Read-only analysis — no file modifications
claude -p "Analyze code quality" \
  --allowedTools "Read" "Glob" "Grep" "Bash(git log *)" \
  --disallowedTools "Write" "Edit"

# Full automation — approve all edits
claude -p "Fix all lint errors" \
  --allowedTools "Read" "Write" "Edit" "Bash"

import { query } from "@anthropic-ai/claude-agent-sdk";

const messages = query({
  prompt: "Find and fix the bug in auth.py",
  options: {
    allowedTools: ["Read", "Edit", "Bash"],
    permissionMode: "acceptEdits",
    model: "sonnet",
    maxTurns: 20,
    maxBudgetUsd: 2.0,
    systemPrompt: {
      type: "preset",
      preset: "claude_code",
      append: "Focus on security best practices.",
    },
  },
});

for await (const message of messages) {
  if (message.type === "assistant") {
    for (const block of message.message.content) {
      if ("text" in block) process.stdout.write(block.text);
    }
  } else if (message.type === "result") {
    console.log(`\nDone: ${message.subtype} | Cost: $${message.total_cost_usd}`);
  }
}

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    async for message in query(
        prompt="Find and fix the bug in auth.py",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Bash"],
            permission_mode="acceptEdits",
            model="sonnet",
            max_turns=20,
            max_budget_usd=2.0,
            system_prompt={"type": "preset", "preset": "claude_code", "append": "Focus on security."},
        ),
    ):
        if hasattr(message, "content"):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text, end="")
        elif hasattr(message, "total_cost_usd"):
            print(f"\nDone: {message.subtype} | Cost: ${message.total_cost_usd}")

asyncio.run(main())

# First invocation — capture session ID
session_id=$(claude -p "Read the auth module and identify issues" \
  --output-format json | jq -r '.session_id')

# Continue with the same context
claude -p "Now fix the issues identified" \
  --resume "$session_id" \
  --output-format json

#!/bin/bash
set -euo pipefail

result=$(claude -p "Review the changes in this PR for bugs and security issues" \
  --output-format json \
  --model sonnet \
  --max-turns 15 \
  --max-budget-usd 3.00 \
  --permission-mode plan \
  --allowedTools "Read" "Glob" "Grep" "Bash(git diff *)" "Bash(git log *)" \
  --no-session-persistence)

is_error=$(echo "$result" | jq -r '.is_error')
cost=$(echo "$result" | jq -r '.total_cost_usd')
review=$(echo "$result" | jq -r '.result')

echo "Cost: \$${cost}"
if [ "$is_error" = "true" ]; then
  echo "Error during review"
  exit 1
fi
echo "$review"

{
  "total_cost_usd": 0.042,
  "duration_ms": 15230,
  "duration_api_ms": 12100,
  "num_turns": 5,
  "usage": {
    "inputTokens": 12500,
    "outputTokens": 3200,
    "cacheReadInputTokens": 8000,
    "cacheCreationInputTokens": 4500
  }
}