Claude Code SDK

claude -p "시스템 성능 분석" \
  --append-system-prompt "당신은 성능 엔지니어입니다" \
  --allowedTools "Bash,Read,WebSearch" \
  --permission-mode acceptEdits \
  --cwd /path/to/project

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

for await (const message of query({
  prompt: "시스템 성능 분석",
  abortController: new AbortController(),
  options: {
    maxTurns: 5,
    systemPrompt: "당신은 성능 엔지니어입니다",
    allowedTools: ["Bash", "Read", "WebSearch"]
  }
})) {
  if (message.type === "result") {
    console.log(message.result);
  }
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def main():
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="당신은 성능 엔지니어입니다",
            allowed_tools=["Bash", "Read", "WebSearch"],
            max_turns=5
        )
    ) as client:
        await client.query("시스템 성능 분석")
        
        # 응답 스트리밍
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)

# 스크립트로 실행
asyncio.run(main())

# 또는 IPython/Jupyter에서: await main()

from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async with ClaudeSDKClient() as client:
    # 텍스트 메시지
    await client.query("이 코드의 보안 문제를 분석하세요")
    
    # 이미지 참조가 포함된 메시지 (이미지는 Claude의 Read 도구로 읽힘)
    await client.query("screenshot.png에 표시된 내용을 설명하세요")
    
    # 순차적으로 여러 메시지
    messages = [
        "먼저 diagram.png의 아키텍처 다이어그램을 분석하세요",
        "이제 다이어그램을 바탕으로 개선 사항을 제안하세요",
        "마지막으로 구현 코드를 생성하세요"
    ]
    
    for msg in messages:
        await client.query(msg)
        async for response in client.receive_response():
            # 각 응답 처리
            pass

# SDK는 Claude의 내장 Read 도구를 통해 이미지 파일을 처리합니다
# 지원되는 형식: PNG, JPG, PDF 및 기타 일반적인 형식

from claude_code_sdk import query, ClaudeCodeOptions

async for message in query(
    prompt="시스템 성능 분석",
    options=ClaudeCodeOptions(system_prompt="당신은 성능 엔지니어입니다")
):
    if type(message).__name__ == "ResultMessage":
        print(message.result)

# 가장 최근 대화 계속
claude --continue "이제 더 나은 성능을 위해 리팩토링하세요"

# 세션 ID로 특정 대화 재개
claude --resume 550e8400-e29b-41d4-a716-446655440000 "테스트를 업데이트하세요"

# 비대화형 모드로 재개
claude --resume 550e8400-e29b-41d4-a716-446655440000 "모든 린팅 문제를 수정하세요" --no-interactive

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

// 가장 최근 대화 계속
for await (const message of query({
  prompt: "이제 더 나은 성능을 위해 리팩토링하세요",
  options: { continueSession: true }
})) {
  if (message.type === "result") console.log(message.result);
}

// 특정 세션 재개
for await (const message of query({
  prompt: "테스트를 업데이트하세요",
  options: { 
    resumeSessionId: "550e8400-e29b-41d4-a716-446655440000",
    maxTurns: 3
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions, query

# 방법 1: 지속적인 대화를 위해 ClaudeSDKClient 사용
async def multi_turn_conversation():
    async with ClaudeSDKClient() as client: 
        # 첫 번째 쿼리
        await client.query("결제 모듈을 리팩토링해봅시다")
        async for msg in client.receive_response():
            # 첫 번째 응답 처리
            pass
        
        # 같은 세션에서 계속
        await client.query("이제 포괄적인 오류 처리를 추가하세요")
        async for msg in client.receive_response():
            # 계속 처리
            pass
        
        # 대화 컨텍스트는 전체적으로 유지됩니다

# 방법 2: 세션 관리와 함께 query 함수 사용
async def resume_session():
    # 가장 최근 대화 계속
    async for message in query(
        prompt="이제 더 나은 성능을 위해 리팩토링하세요",
        options=ClaudeCodeOptions(continue_conversation=True)
    ):
        if type(message).__name__ == "ResultMessage":
            print(message.result)

    # 특정 세션 재개
    async for message in query(
        prompt="테스트를 업데이트하세요", 
        options=ClaudeCodeOptions(
            resume="550e8400-e29b-41d4-a716-446655440000",
            max_turns=3
        )
    ):
        if type(message).__name__ == "ResultMessage":
            print(message.result)

# 예시 실행
asyncio.run(multi_turn_conversation())

claude -p "이 코드를 검토하세요" --permission-mode plan

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

for await (const message of query({
  prompt: "여기에 프롬프트를 입력하세요",
  options: {
    permissionMode: 'plan'
  }
})) {
  if (message.type === "result") {
    console.log(message.result);
  }
}

from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async with ClaudeSDKClient(
    options=ClaudeCodeOptions(permission_mode='plan')
) as client:
    await client.query("여기에 프롬프트를 입력하세요")

# SRE 인시던트 대응 에이전트
claude -p "API가 다운되었습니다. 조사하세요" \
  --append-system-prompt "당신은 SRE 전문가입니다. 문제를 체계적으로 진단하고 실행 가능한 솔루션을 제공하세요."

# 법무 문서 검토 에이전트  
claude -p "이 계약서를 검토하세요" \
  --append-system-prompt "당신은 기업 변호사입니다. 위험을 식별하고 개선 사항을 제안하며 규정 준수를 보장하세요."

# 기본 시스템 프롬프트에 추가
claude -p "이 함수를 리팩토링하세요" \
  --append-system-prompt "항상 포괄적인 오류 처리와 단위 테스트를 포함하세요."

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

// SRE 인시던트 대응 에이전트
for await (const message of query({
  prompt: "API가 다운되었습니다. 조사하세요",
  options: {
    systemPrompt: "당신은 SRE 전문가입니다. 문제를 체계적으로 진단하고 실행 가능한 솔루션을 제공하세요.",
    maxTurns: 3
  }
})) {
  if (message.type === "result") console.log(message.result);
}

// 기본 시스템 프롬프트에 추가
for await (const message of query({
  prompt: "이 함수를 리팩토링하세요",
  options: {
    appendSystemPrompt: "항상 포괄적인 오류 처리와 단위 테스트를 포함하세요.",
    maxTurns: 2
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def specialized_agents():
    # 스트리밍을 사용한 SRE 인시던트 대응 에이전트
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="당신은 SRE 전문가입니다. 문제를 체계적으로 진단하고 실행 가능한 솔루션을 제공하세요.",
            max_turns=3
        )
    ) as sre_agent:
        await sre_agent.query("API가 다운되었습니다. 조사하세요")
        
        # 진단 과정 스트리밍
        async for message in sre_agent.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
    
    # 사용자 정의 프롬프트를 사용한 법무 검토 에이전트
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            append_system_prompt="항상 포괄적인 오류 처리와 단위 테스트를 포함하세요.",
            max_turns=2
        )
    ) as dev_agent:
        await dev_agent.query("이 함수를 리팩토링하세요")
        
        # 전체 응답 수집
        full_response = []
        async for message in dev_agent.receive_response():
            if type(message).__name__ == "ResultMessage":
                print(message.result)

asyncio.run(specialized_agents())

# 모니터링 도구를 사용한 SRE 에이전트
claude -p "결제 서비스 장애를 조사하세요" \
  --mcp-config sre-tools.json \
  --allowedTools "mcp__datadog,mcp__pagerduty,mcp__kubernetes" \
  --append-system-prompt "당신은 SRE입니다. 모니터링 데이터를 사용하여 문제를 진단하세요."

# CRM 액세스를 사용한 고객 지원 에이전트
claude -p "고객 티켓 #12345 해결을 도와주세요" \
  --mcp-config support-tools.json \
  --allowedTools "mcp__zendesk,mcp__stripe,mcp__user_db" \
  --append-system-prompt "당신은 기술 지원 전문가입니다."

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

// 모니터링 도구를 사용한 SRE 에이전트
for await (const message of query({
  prompt: "결제 서비스 장애를 조사하세요",
  options: {
    mcpConfig: "sre-tools.json",
    allowedTools: ["mcp__datadog", "mcp__pagerduty", "mcp__kubernetes"],
    systemPrompt: "당신은 SRE입니다. 모니터링 데이터를 사용하여 문제를 진단하세요.",
    maxTurns: 4
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def mcp_enabled_agent():
    # 문서 액세스 및 스트리밍을 사용한 법무 에이전트
    # 참고: 필요에 따라 MCP 서버를 구성하세요
    mcp_servers = {
        # 예시 구성 - 필요에 따라 주석을 해제하고 구성하세요:
        # "docusign": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-docusign"],
        #     "env": {"API_KEY": "your-key"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            mcp_servers=mcp_servers,
            allowed_tools=["mcp__docusign", "mcp__compliance_db"],
            system_prompt="당신은 계약 검토를 전문으로 하는 기업 변호사입니다.",
            max_turns=4
        )
    ) as client:
        await client.query("이 계약서의 규정 준수 위험을 검토하세요")
        
        # 도구 사용 및 응답 모니터링
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):
                        if block.type == 'tool_use':
                            print(f"\n[도구 사용: {block.name}]\n")
                        elif hasattr(block, 'text'):
                            print(block.text, end='', flush=True)
                    elif hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
            
            if type(message).__name__ == "ResultMessage":
                print(f"\n\n검토 완료. 총 비용: ${message.total_cost_usd:.4f}")

asyncio.run(mcp_enabled_agent())

# MCP 서버 구성과 함께 사용
claude -p "보안 문제를 분석하고 수정하세요" \
  --permission-prompt-tool mcp__security__approval_prompt \
  --mcp-config security-tools.json \
  --allowedTools "Read,Grep" \
  --disallowedTools "Bash(rm*),Write"

# 사용자 정의 권한 규칙과 함께
claude -p "코드베이스를 리팩토링하세요" \
  --permission-prompt-tool mcp__custom__permission_check \
  --mcp-config custom-config.json \
  --output-format json

const server = new McpServer({
  name: "Test permission prompt MCP Server",
  version: "0.0.1",
});

server.tool(
  "approval_prompt",
  '권한 확인 시뮬레이션 - 입력에 "allow"가 포함되어 있으면 승인, 그렇지 않으면 거부',
  {
    tool_name: z.string().describe("권한을 요청하는 도구의 이름"),
    input: z.object({}).passthrough().describe("도구의 입력"),
    tool_use_id: z.string().optional().describe("고유한 도구 사용 요청 ID"),
  },
  async ({ tool_name, input }) => {
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            JSON.stringify(input).includes("allow")
              ? {
                  behavior: "allow",
                  updatedInput: input,
                }
              : {
                  behavior: "deny",
                  message: "테스트 approval_prompt 도구에 의해 권한이 거부되었습니다",
                }
          ),
        },
      ],
    };
  }
);

// SDK에서 사용
import { query } from "@anthropic-ai/claude-code";

for await (const message of query({
  prompt: "코드베이스를 분석하세요",
  options: {
    permissionPromptTool: "mcp__test-server__approval_prompt",
    mcpConfig: "my-config.json",
    allowedTools: ["Read", "Grep"]
  }
})) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def use_permission_prompt():
    """사용자 정의 권한 프롬프트 도구 사용 예시"""
    
    # MCP 서버 구성
    mcp_servers = {
        # 예시 구성 - 필요에 따라 주석을 해제하고 구성하세요:
        # "security": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-security"],
        #     "env": {"API_KEY": "your-key"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            permission_prompt_tool_name="mcp__security__approval_prompt",  # permission_prompt_tool에서 변경됨
            mcp_servers=mcp_servers,
            allowed_tools=["Read", "Grep"],
            disallowed_tools=["Bash(rm*)", "Write"],
            system_prompt="당신은 보안 감사관입니다"
        )
    ) as client:
        await client.query("보안 문제를 분석하고 수정하세요")
        
        # 도구 사용 및 권한 모니터링
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):  # 'type' 속성 확인 추가
                        if block.type == 'tool_use':
                            print(f"[도구: {block.name}] ", end='')
                    if hasattr(block, 'text'):
                        print(block.text, end='', flush=True)
            
            # 오류 메시지에서 권한 거부 확인
            if type(message).__name__ == "ErrorMessage":
                if hasattr(message, 'error') and "Permission denied" in str(message.error):
                    print(f"\n⚠️ 권한 거부: {message.error}")

# 예시 MCP 서버 구현 (Python)
# 이는 MCP 서버 코드에 있을 것입니다
async def approval_prompt(tool_name: str, input: dict, tool_use_id: str = None):
    """사용자 정의 권한 프롬프트 핸들러"""
    # 여기에 사용자 정의 로직
    if "allow" in str(input):
        return json.dumps({
            "behavior": "allow",
            "updatedInput": input
        })
    else:
        return json.dumps({
            "behavior": "deny",
            "message": f"{tool_name}에 대한 권한이 거부되었습니다"
        })

asyncio.run(use_permission_prompt())

claude -p "src/components/Header.tsx 파일을 설명하세요"
# 출력: 이것은 다음을 보여주는 React 컴포넌트입니다...

// 기본 텍스트 출력
for await (const message of query({
  prompt: "src/components/Header.tsx 파일을 설명하세요"
})) {
  if (message.type === "result") {
    console.log(message.result);
    // 출력: 이것은 다음을 보여주는 React 컴포넌트입니다...
  }
}

# 스트리밍을 사용한 기본 텍스트 출력
async with ClaudeSDKClient() as client:
    await client.query("src/components/Header.tsx 파일을 설명하세요")
    
    # 텍스트가 도착하는 대로 스트리밍
    async for message in client.receive_response():
        if hasattr(message, 'content'):
            for block in message.content:
                if hasattr(block, 'text'):
                    print(block.text, end='', flush=True)
                    # 출력이 실시간으로 스트리밍됩니다: 이것은 다음을 보여주는 React 컴포넌트입니다...

claude -p "데이터 레이어는 어떻게 작동하나요?" --output-format json

// JSON과 같은 액세스를 위해 모든 메시지 수집
const messages = [];
for await (const message of query({
  prompt: "데이터 레이어는 어떻게 작동하나요?"
})) {
  messages.push(message);
}

// 메타데이터가 포함된 결과 메시지 액세스
const result = messages.find(m => m.type === "result");
console.log({
  result: result.result,
  cost: result.total_cost_usd,
  duration: result.duration_ms
});

# 메타데이터와 함께 모든 메시지 수집
async with ClaudeSDKClient() as client:
    await client.query("데이터 레이어는 어떻게 작동하나요?")
    
    messages = []
    result_data = None
    
    async for message in client.receive_messages():
        messages.append(message)
        
        # 메타데이터가 포함된 결과 메시지 캡처
        if type(message).__name__ == "ResultMessage":
            result_data = {
                "result": message.result,
                "cost": message.total_cost_usd,
                "duration": message.duration_ms,
                "num_turns": message.num_turns,
                "session_id": message.session_id
            }
            break
    
    print(result_data)

# 직접 인수
claude -p "이 코드를 설명하세요"

# stdin에서
echo "이 코드를 설명하세요" | claude -p

// 직접 프롬프트
for await (const message of query({
  prompt: "이 코드를 설명하세요"
})) {
  if (message.type === "result") console.log(message.result);
}

// 변수에서
const userInput = "이 코드를 설명하세요";
for await (const message of query({ prompt: userInput })) {
  if (message.type === "result") console.log(message.result);
}

import asyncio
from claude_code_sdk import ClaudeSDKClient

async def process_inputs():
    async with ClaudeSDKClient() as client:
        # 텍스트 입력
        await client.query("이 코드를 설명하세요")
        async for message in client.receive_response():
            # 스트리밍 응답 처리
            pass
        
        # 이미지 입력 (Claude가 자동으로 Read 도구 사용)
        await client.query("이 다이어그램에 무엇이 있나요? screenshot.png")
        async for message in client.receive_response():
            # 이미지 분석 처리
            pass
        
        # 혼합 콘텐츠를 사용한 여러 입력
        inputs = [
            "diagram.png의 아키텍처를 분석하세요",
            "모범 사례와 비교하세요",
            "개선된 버전을 생성하세요"
        ]
        
        for prompt in inputs:
            await client.query(prompt)
            async for message in client.receive_response():
                # 각 응답 처리
                pass

asyncio.run(process_inputs())

#!/bin/bash

# 자동화된 인시던트 대응 에이전트
investigate_incident() {
    local incident_description="$1"
    local severity="${2:-medium}"
    
    claude -p "인시던트: $incident_description (심각도: $severity)" \
      --append-system-prompt "당신은 SRE 전문가입니다. 문제를 진단하고 영향을 평가하며 즉각적인 조치 항목을 제공하세요." \
      --output-format json \
      --allowedTools "Bash,Read,WebSearch,mcp__datadog" \
      --mcp-config monitoring-tools.json
}

# 사용법
investigate_incident "결제 API가 500 오류를 반환합니다" "high"

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

// 자동화된 인시던트 대응 에이전트
async function investigateIncident(
  incidentDescription: string, 
  severity = "medium"
) {
  const messages = [];
  
  for await (const message of query({
    prompt: `인시던트: ${incidentDescription} (심각도: ${severity})`,
    options: {
      systemPrompt: "당신은 SRE 전문가입니다. 문제를 진단하고 영향을 평가하며 즉각적인 조치 항목을 제공하세요.",
      maxTurns: 6,
      allowedTools: ["Bash", "Read", "WebSearch", "mcp__datadog"],
      mcpConfig: "monitoring-tools.json"
    }
  })) {
    messages.push(message);
  }
  
  return messages.find(m => m.type === "result");
}

// 사용법
const result = await investigateIncident("결제 API가 500 오류를 반환합니다", "high");
console.log(result.result);

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def investigate_incident(incident_description: str, severity: str = "medium"):
    """실시간 스트리밍을 사용한 자동화된 인시던트 대응 에이전트"""
    
    # 모니터링 도구용 MCP 서버 구성
    mcp_servers = {
        # 예시 구성 - 필요에 따라 주석을 해제하고 구성하세요:
        # "datadog": {
        #     "command": "npx",
        #     "args": ["-y", "@modelcontextprotocol/server-datadog"],
        #     "env": {"API_KEY": "your-datadog-key", "APP_KEY": "your-app-key"}
        # }
    }
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="당신은 SRE 전문가입니다. 문제를 진단하고 영향을 평가하며 즉각적인 조치 항목을 제공하세요.",
            max_turns=6,
            allowed_tools=["Bash", "Read", "WebSearch", "mcp__datadog"],
            mcp_servers=mcp_servers
        )
    ) as client:
        # 인시던트 세부 정보 전송
        prompt = f"인시던트: {incident_description} (심각도: {severity})"
        print(f"🚨 조사 중: {prompt}\n")
        await client.query(prompt)
        
        # 조사 과정 스트리밍
        investigation_log = []
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'type'):
                        if block.type == 'tool_use':
                            print(f"[{block.name}] ", end='')
                    if hasattr(block, 'text'):
                        text = block.text
                        print(text, end='', flush=True)
                        investigation_log.append(text)
            
            # 최종 결과 캡처
            if type(message).__name__ == "ResultMessage":
                return {
                    'analysis': ''.join(investigation_log),
                    'cost': message.total_cost_usd,
                    'duration_ms': message.duration_ms
                }

# 사용법
result = await investigate_incident("결제 API가 500 오류를 반환합니다", "high")
print(f"\n\n조사 완료. 비용: ${result['cost']:.4f}")

# 풀 리퀘스트용 보안 감사 에이전트
audit_pr() {
    local pr_number="$1"
    
    gh pr diff "$pr_number" | claude -p \
      --append-system-prompt "당신은 보안 엔지니어입니다. 이 PR의 취약점, 안전하지 않은 패턴 및 규정 준수 문제를 검토하세요." \
      --output-format json \
      --allowedTools "Read,Grep,WebSearch"
}

# 사용법 및 파일로 저장
audit_pr 123 > security-report.json

import { query } from "@anthropic-ai/claude-code";
import { execSync } from "child_process";

async function auditPR(prNumber: number) {
  // PR diff 가져오기
  const prDiff = execSync(`gh pr diff ${prNumber}`, { encoding: 'utf8' });
  
  const messages = [];
  for await (const message of query({
    prompt: prDiff,
    options: {
      systemPrompt: "당신은 보안 엔지니어입니다. 이 PR의 취약점, 안전하지 않은 패턴 및 규정 준수 문제를 검토하세요.",
      maxTurns: 3,
      allowedTools: ["Read", "Grep", "WebSearch"]
    }
  })) {
    messages.push(message);
  }
  
  return messages.find(m => m.type === "result");
}

// 사용법
const report = await auditPR(123);
console.log(JSON.stringify(report, null, 2));

import subprocess
import asyncio
import json
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def audit_pr(pr_number: int):
    """스트리밍 피드백을 사용한 풀 리퀘스트용 보안 감사 에이전트"""
    # PR diff 가져오기
    pr_diff = subprocess.check_output(
        ["gh", "pr", "diff", str(pr_number)], 
        text=True
    )
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="당신은 보안 엔지니어입니다. 이 PR의 취약점, 안전하지 않은 패턴 및 규정 준수 문제를 검토하세요.",
            max_turns=3,
            allowed_tools=["Read", "Grep", "WebSearch"]
        )
    ) as client:
        print(f"🔍 PR #{pr_number} 감사 중\n")
        await client.query(pr_diff)
        
        findings = []
        async for message in client.receive_response():
            if hasattr(message, 'content'):
                for block in message.content:
                    if hasattr(block, 'text'):
                        # 발견 사항이 발견되는 대로 스트리밍
                        print(block.text, end='', flush=True)
                        findings.append(block.text)
            
            if type(message).__name__ == "ResultMessage":
                return {
                    'pr_number': pr_number,
                    'findings': ''.join(findings),
                    'metadata': {
                        'cost': message.total_cost_usd,
                        'duration': message.duration_ms,
                        'severity': 'high' if 'vulnerability' in ''.join(findings).lower() else 'medium'
                    }
                }

# 사용법
report = await audit_pr(123)
print(f"\n\n감사 완료. 심각도: {report['metadata']['severity']}")
print(json.dumps(report, indent=2))

# 세션 지속성을 사용한 법무 문서 검토
session_id=$(claude -p "법무 검토 세션을 시작하세요" --output-format json | jq -r '.session_id')

# 여러 단계로 계약서 검토
claude -p --resume "$session_id" "contract.pdf의 책임 조항을 검토하세요"
claude -p --resume "$session_id" "GDPR 요구 사항 준수를 확인하세요" 
claude -p --resume "$session_id" "위험의 경영진 요약을 생성하세요"

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

async function legalReview() {
  // 법무 검토 세션 시작
  let sessionId: string;
  
  for await (const message of query({
    prompt: "법무 검토 세션을 시작하세요",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      sessionId = message.session_id;
    }
  }
  
  // 같은 세션을 사용한 다단계 검토
  const steps = [
    "contract.pdf의 책임 조항을 검토하세요",
    "GDPR 요구 사항 준수를 확인하세요",
    "위험의 경영진 요약을 생성하세요"
  ];
  
  for (const step of steps) {
    for await (const message of query({
      prompt: step,
      options: { resumeSessionId: sessionId, maxTurns: 2 }
    })) {
      if (message.type === "result") {
        console.log(`단계: ${step}`);
        console.log(message.result);
      }
    }
  }
}

import asyncio
from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions

async def legal_review():
    """지속적인 세션과 스트리밍을 사용한 법무 문서 검토"""
    
    async with ClaudeSDKClient(
        options=ClaudeCodeOptions(
            system_prompt="당신은 기업 변호사입니다. 상세한 법적 분석을 제공하세요.",
            max_turns=2
        )
    ) as client:
        # 같은 세션에서 다단계 검토
        steps = [
            "contract.pdf의 책임 조항을 검토하세요",
            "GDPR 요구 사항 준수를 확인하세요", 
            "위험의 경영진 요약을 생성하세요"
        ]
        
        review_results = []
        
        for step in steps:
            print(f"\n📋 {step}\n")
            await client.query(step)
            
            step_result = []
            async for message in client.receive_response():
                if hasattr(message, 'content'):
                    for block in message.content:
                        if hasattr(block, 'text'):
                            text = block.text
                            print(text, end='', flush=True)
                            step_result.append(text)
                
                if type(message).__name__ == "ResultMessage":
                    review_results.append({
                        'step': step,
                        'analysis': ''.join(step_result),
                        'cost': message.total_cost_usd
                    })
        
        # 요약
        total_cost = sum(r['cost'] for r in review_results)
        print(f"\n\n✅ 법무 검토 완료. 총 비용: ${total_cost:.4f}")
        return review_results

# 사용법
results = await legal_review()