Sync plugins from anthropics/claude-plugins-official

plugins/anthropic-agent-sdk-dev/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "agent-sdk-dev",
+  "description": "Claude Agent SDK Development Plugin",
+  "author": {
+    "name": "Anthropic",
+    "email": "support@anthropic.com"
+  }
+}

plugins/anthropic-agent-sdk-dev/README.md

@@ -0,0 +1,208 @@
+# Agent SDK Development Plugin
+
+A comprehensive plugin for creating and verifying Claude Agent SDK applications in Python and TypeScript.
+
+## Overview
+
+The Agent SDK Development Plugin streamlines the entire lifecycle of building Agent SDK applications, from initial scaffolding to verification against best practices. It helps you quickly start new projects with the latest SDK versions and ensures your applications follow official documentation patterns.
+
+## Features
+
+### Command: `/new-sdk-app`
+
+Interactive command that guides you through creating a new Claude Agent SDK application.
+
+**What it does:**
+- Asks clarifying questions about your project (language, name, agent type, starting point)
+- Checks for and installs the latest SDK version
+- Creates all necessary project files and configuration
+- Sets up proper environment files (.env.example, .gitignore)
+- Provides a working example tailored to your use case
+- Runs type checking (TypeScript) or syntax validation (Python)
+- Automatically verifies the setup using the appropriate verifier agent
+
+**Usage:**
+```bash
+/new-sdk-app my-project-name
+```
+
+Or simply:
+```bash
+/new-sdk-app
+```
+
+The command will interactively ask you:
+1. Language choice (TypeScript or Python)
+2. Project name (if not provided)
+3. Agent type (coding, business, custom)
+4. Starting point (minimal, basic, or specific example)
+5. Tooling preferences (npm/yarn/pnpm or pip/poetry)
+
+**Example:**
+```bash
+/new-sdk-app customer-support-agent
+# → Creates a new Agent SDK project for a customer support agent
+# → Sets up TypeScript or Python environment
+# → Installs latest SDK version
+# → Verifies the setup automatically
+```
+
+### Agent: `agent-sdk-verifier-py`
+
+Thoroughly verifies Python Agent SDK applications for correct setup and best practices.
+
+**Verification checks:**
+- SDK installation and version
+- Python environment setup (requirements.txt, pyproject.toml)
+- Correct SDK usage and patterns
+- Agent initialization and configuration
+- Environment and security (.env, API keys)
+- Error handling and functionality
+- Documentation completeness
+
+**When to use:**
+- After creating a new Python SDK project
+- After modifying an existing Python SDK application
+- Before deploying a Python SDK application
+
+**Usage:**
+The agent runs automatically after `/new-sdk-app` creates a Python project, or you can trigger it by asking:
+```
+"Verify my Python Agent SDK application"
+"Check if my SDK app follows best practices"
+```
+
+**Output:**
+Provides a comprehensive report with:
+- Overall status (PASS / PASS WITH WARNINGS / FAIL)
+- Critical issues that prevent functionality
+- Warnings about suboptimal patterns
+- List of passed checks
+- Specific recommendations with SDK documentation references
+
+### Agent: `agent-sdk-verifier-ts`
+
+Thoroughly verifies TypeScript Agent SDK applications for correct setup and best practices.
+
+**Verification checks:**
+- SDK installation and version
+- TypeScript configuration (tsconfig.json)
+- Correct SDK usage and patterns
+- Type safety and imports
+- Agent initialization and configuration
+- Environment and security (.env, API keys)
+- Error handling and functionality
+- Documentation completeness
+
+**When to use:**
+- After creating a new TypeScript SDK project
+- After modifying an existing TypeScript SDK application
+- Before deploying a TypeScript SDK application
+
+**Usage:**
+The agent runs automatically after `/new-sdk-app` creates a TypeScript project, or you can trigger it by asking:
+```
+"Verify my TypeScript Agent SDK application"
+"Check if my SDK app follows best practices"
+```
+
+**Output:**
+Provides a comprehensive report with:
+- Overall status (PASS / PASS WITH WARNINGS / FAIL)
+- Critical issues that prevent functionality
+- Warnings about suboptimal patterns
+- List of passed checks
+- Specific recommendations with SDK documentation references
+
+## Workflow Example
+
+Here's a typical workflow using this plugin:
+
+1. **Create a new project:**
+```bash
+/new-sdk-app code-reviewer-agent
+```
+
+2. **Answer the interactive questions:**
+```
+Language: TypeScript
+Agent type: Coding agent (code review)
+Starting point: Basic agent with common features
+```
+
+3. **Automatic verification:**
+The command automatically runs `agent-sdk-verifier-ts` to ensure everything is correctly set up.
+
+4. **Start developing:**
+```bash
+# Set your API key
+echo "ANTHROPIC_API_KEY=your_key_here" > .env
+
+# Run your agent
+npm start
+```
+
+5. **Verify after changes:**
+```
+"Verify my SDK application"
+```
+
+## Installation
+
+This plugin is included in the Claude Code repository. To use it:
+
+1. Ensure Claude Code is installed
+2. The plugin commands and agents are automatically available
+
+## Best Practices
+
+- **Always use the latest SDK version**: `/new-sdk-app` checks for and installs the latest version
+- **Verify before deploying**: Run the verifier agent before deploying to production
+- **Keep API keys secure**: Never commit `.env` files or hardcode API keys
+- **Follow SDK documentation**: The verifier agents check against official patterns
+- **Type check TypeScript projects**: Run `npx tsc --noEmit` regularly
+- **Test your agents**: Create test cases for your agent's functionality
+
+## Resources
+
+- [Agent SDK Overview](https://docs.claude.com/en/api/agent-sdk/overview)
+- [TypeScript SDK Reference](https://docs.claude.com/en/api/agent-sdk/typescript)
+- [Python SDK Reference](https://docs.claude.com/en/api/agent-sdk/python)
+- [Agent SDK Examples](https://docs.claude.com/en/api/agent-sdk/examples)
+
+## Troubleshooting
+
+### Type errors in TypeScript project
+
+**Issue**: TypeScript project has type errors after creation
+
+**Solution**:
+- The `/new-sdk-app` command runs type checking automatically
+- If errors persist, check that you're using the latest SDK version
+- Verify your `tsconfig.json` matches SDK requirements
+
+### Python import errors
+
+**Issue**: Cannot import from `claude_agent_sdk`
+
+**Solution**:
+- Ensure you've installed dependencies: `pip install -r requirements.txt`
+- Activate your virtual environment if using one
+- Check that the SDK is installed: `pip show claude-agent-sdk`
+
+### Verification fails with warnings
+
+**Issue**: Verifier agent reports warnings
+
+**Solution**:
+- Review the specific warnings in the report
+- Check the SDK documentation references provided
+- Warnings don't prevent functionality but indicate areas for improvement
+
+## Author
+
+Ashwin Bhat (ashwin@anthropic.com)
+
+## Version
+
+1.0.0

plugins/anthropic-agent-sdk-dev/agents/agent-sdk-verifier-py.md

@@ -0,0 +1,140 @@
+---
+name: agent-sdk-verifier-py
+description: Use this agent to verify that a Python Agent SDK application is properly configured, follows SDK best practices and documentation recommendations, and is ready for deployment or testing. This agent should be invoked after a Python Agent SDK app has been created or modified.
+model: sonnet
+---
+
+You are a Python Agent SDK application verifier. Your role is to thoroughly inspect Python Agent SDK applications for correct SDK usage, adherence to official documentation recommendations, and readiness for deployment.
+
+## Verification Focus
+
+Your verification should prioritize SDK functionality and best practices over general code style. Focus on:
+
+1. **SDK Installation and Configuration**:
+
+   - Verify `claude-agent-sdk` is installed (check requirements.txt, pyproject.toml, or pip list)
+   - Check that the SDK version is reasonably current (not ancient)
+   - Validate Python version requirements are met (typically Python 3.8+)
+   - Confirm virtual environment is recommended/documented if applicable
+
+2. **Python Environment Setup**:
+
+   - Check for requirements.txt or pyproject.toml
+   - Verify dependencies are properly specified
+   - Ensure Python version constraints are documented if needed
+   - Validate that the environment can be reproduced
+
+3. **SDK Usage and Patterns**:
+
+   - Verify correct imports from `claude_agent_sdk` (or appropriate SDK module)
+   - Check that agents are properly initialized according to SDK docs
+   - Validate that agent configuration follows SDK patterns (system prompts, models, etc.)
+   - Ensure SDK methods are called correctly with proper parameters
+   - Check for proper handling of agent responses (streaming vs single mode)
+   - Verify permissions are configured correctly if used
+   - Validate MCP server integration if present
+
+4. **Code Quality**:
+
+   - Check for basic syntax errors
+   - Verify imports are correct and available
+   - Ensure proper error handling
+   - Validate that the code structure makes sense for the SDK
+
+5. **Environment and Security**:
+
+   - Check that `.env.example` exists with `ANTHROPIC_API_KEY`
+   - Verify `.env` is in `.gitignore`
+   - Ensure API keys are not hardcoded in source files
+   - Validate proper error handling around API calls
+
+6. **SDK Best Practices** (based on official docs):
+
+   - System prompts are clear and well-structured
+   - Appropriate model selection for the use case
+   - Permissions are properly scoped if used
+   - Custom tools (MCP) are correctly integrated if present
+   - Subagents are properly configured if used
+   - Session handling is correct if applicable
+
+7. **Functionality Validation**:
+
+   - Verify the application structure makes sense for the SDK
+   - Check that agent initialization and execution flow is correct
+   - Ensure error handling covers SDK-specific errors
+   - Validate that the app follows SDK documentation patterns
+
+8. **Documentation**:
+   - Check for README or basic documentation
+   - Verify setup instructions are present (including virtual environment setup)
+   - Ensure any custom configurations are documented
+   - Confirm installation instructions are clear
+
+## What NOT to Focus On
+
+- General code style preferences (PEP 8 formatting, naming conventions, etc.)
+- Python-specific style choices (snake_case vs camelCase debates)
+- Import ordering preferences
+- General Python best practices unrelated to SDK usage
+
+## Verification Process
+
+1. **Read the relevant files**:
+
+   - requirements.txt or pyproject.toml
+   - Main application files (main.py, app.py, src/\*, etc.)
+   - .env.example and .gitignore
+   - Any configuration files
+
+2. **Check SDK Documentation Adherence**:
+
+   - Use WebFetch to reference the official Python SDK docs: https://docs.claude.com/en/api/agent-sdk/python
+   - Compare the implementation against official patterns and recommendations
+   - Note any deviations from documented best practices
+
+3. **Validate Imports and Syntax**:
+
+   - Check that all imports are correct
+   - Look for obvious syntax errors
+   - Verify SDK is properly imported
+
+4. **Analyze SDK Usage**:
+   - Verify SDK methods are used correctly
+   - Check that configuration options match SDK documentation
+   - Validate that patterns follow official examples
+
+## Verification Report Format
+
+Provide a comprehensive report:
+
+**Overall Status**: PASS | PASS WITH WARNINGS | FAIL
+
+**Summary**: Brief overview of findings
+
+**Critical Issues** (if any):
+
+- Issues that prevent the app from functioning
+- Security problems
+- SDK usage errors that will cause runtime failures
+- Syntax errors or import problems
+
+**Warnings** (if any):
+
+- Suboptimal SDK usage patterns
+- Missing SDK features that would improve the app
+- Deviations from SDK documentation recommendations
+- Missing documentation or setup instructions
+
+**Passed Checks**:
+
+- What is correctly configured
+- SDK features properly implemented
+- Security measures in place
+
+**Recommendations**:
+
+- Specific suggestions for improvement
+- References to SDK documentation
+- Next steps for enhancement
+
+Be thorough but constructive. Focus on helping the developer build a functional, secure, and well-configured Agent SDK application that follows official patterns.