09-Claude-Code集成与扩展

Claude Code 集成与扩展

📚 免费专栏全套教程： Claude Code 从入门到精通 ✦ 开篇总览｜最新目录： Claude Code 从入门到精通 —带你玩转Claude Code！！ Claude Code 作为一款强大的 AI 编程助手，其真正的威力在于与其他开发工具和工作流的无缝集成。本章将深入探讨如何将 Claude Code 融入你的开发生态系统，从 IDE 到 CI/CD，再到自定义扩展开发。

目录

1. IDE 集成

1.1 Visual Studio Code 集成

官方扩展安装

Claude Code 提供了官方的 VS Code 扩展，支持深度集成：

# 通过命令行安装
code –install-extension anthropic.claude-code

# 或在 VS Code 扩展市场搜索 "Claude Code" 安装

核心功能

配置优化

在 .vscode/settings.json 中添加 Claude Code 相关配置：

{
"claude-code.enable": true,
"claude-code.model": "claude-3-5-sonnet",
"claude-code.maxTokens": 4096,
"claude-code.temperature": 0.7,
"claude-code.inlineCompletion": {
"enabled": true,
"delay": 300
},
"claude-code.codeActions": {
"quickFix": true,
"refactor": true,
"documentation": true
}
}

工作区配置

创建 .claudecode/config.json 文件定制项目级设置：

{
"projectContext": {
"language": "typescript",
"framework": "react",
"testingFramework": "jest"
},
"rules": [
"使用函数式组件",
"遵循 Airbnb 代码规范",
"组件命名使用 PascalCase"
],
"ignorePatterns": [
"node_modules/**",
"dist/**",
"*.min.js"
]
}

1.2 JetBrains IDEs 集成

支持的 IDE

• IntelliJ IDEA
• PyCharm
• WebStorm
• GoLand
• PhpStorm
• RubyMine

插件安装

功能特性

// 在 Kotlin 中使用 Claude Code 注解
@ClaudeSuggestion("优化这个函数的性能")
fun processData(items: List<Item>): Result {
// Claude 会分析并提供优化建议
}

快捷键映射

Mac:
– Cmd+Option+C: 打开 Claude Code 面板
– Cmd+Option+S: 发送选中代码
– Cmd+Option+F: 格式化并优化代码

Windows/Linux:
– Ctrl+Alt+C: 打开 Claude Code 面板
– Ctrl+Alt+S: 发送选中代码
– Ctrl+Alt+F: 格式化并优化代码

1.3 Vim/Neovim 集成

使用 vim-claudecode 插件

" 在 .vimrc 或 init.vim 中添加
Plug 'anthropic/vim-claudecode'

" 配置
let g:claudecode_api_key = $CLAUDE_API_KEY
let g:claudecode_model = 'claude-3-5-sonnet'
let g:claudecode_auto_suggest = 1

" 快捷键映射
nnoremap <leader>cc :ClaudeCode<CR>
vnoremap <leader>cs :ClaudeCodeSend<CR>
nnoremap <leader>ce :ClaudeCodeExplain<CR>
nnoremap <leader>cr :ClaudeCodeRefactor<CR>

Neovim Lua 配置

— init.lua
require('claudecode').setup({
api_key = os.getenv('CLAUDE_API_KEY'),
model = 'claude-3-5-sonnet',
keymaps = {
open = '<leader>cc',
send = '<leader>cs',
explain = '<leader>ce',
refactor = '<leader>cr'
},
ui = {
float = true,
border = 'rounded',
width = 80,
height = 20
}
})

1.4 Emacs 集成

;; init.el
(use-package claude-code
:ensure t
:config
(setq claude-code-api-key (getenv "CLAUDE_API_KEY"))
(setq claude-code-model "claude-3-5-sonnet")

:bind
(("C-c c c" . claude-code-open)
("C-c c s" . claude-code-send-region)
("C-c c e" . claude-code-explain)
("C-c c r" . claude-code-refactor)))

2. Git 工作流集成

2.1 提交消息生成

自动生成提交消息

Claude Code 可以分析暂存的变更，自动生成符合规范的提交消息：

# 安装 Claude Code Git hooks
claude-code install-hooks

# 自动生成提交消息
git add .
claude-code commit

生成的提交消息示例：

feat(auth): implement OAuth2 login flow

– Add OAuth2 authentication provider
– Implement token refresh mechanism
– Add user session management
– Update auth middleware to validate tokens

Refs: #123

提交消息模板配置

创建 .claudecode/commit-template.json：

{
"format": "conventional-commits",
"types": ["feat", "fix", "docs", "style", "refactor", "test", "chore"],
"scopes": ["auth", "api", "ui", "db", "core"],
"includeIssueNumber": true,
"maxLength": 72,
"rules": [
"使用祈使语气",
"首字母大写",
"不使用句号结尾",
"包含简短描述和详细说明"
]
}

2.2 代码审查集成

PR 描述生成

# 为当前分支生成 PR 描述
claude-code pr-generate –base main

# 输出示例：
# ## Summary
# This PR implements the new user dashboard with real-time analytics.
#
# ## Changes
# – Add dashboard component with chart visualizations
# – Implement WebSocket connection for real-time updates
# – Add analytics service for data aggregation
# – Update user service to track dashboard preferences
#
# ## Testing
# – Unit tests added for dashboard component
# – Integration tests for WebSocket handling
# – E2E tests for critical user flows
#
# ## Screenshots
# [Dashboard preview]

自动代码审查

创建 .claudecode/review-rules.md：

# Code Review Rules

## 安全性检查
– 检查敏感信息泄露（API keys, passwords）
– 验证输入数据清洗
– 检查 SQL 注入风险

## 代码质量
– 圈复杂度不超过 10
– 函数长度不超过 50 行
– 单一职责原则

## 性能考量
– 避免 N+1 查询
– 检查循环中的数据库操作
– 验证缓存使用

## 最佳实践
– 遵循项目代码规范
– 检查错误处理
– 验证日志记录

运行审查：

# 审查当前分支的所有变更
claude-code review –base main –output review.md

# 审查特定文件
claude-code review src/auth/login.ts

# 审查并自动修复简单问题
claude-code review –auto-fix

2.3 分支管理

智能分支命名

# 根据变更内容建议分支名
claude-code suggest-branch

# 输出：
# 建议分支名称：
# 1. feature/add-dark-mode
# 2. feat/ui/dark-theme
# 3. enhancement/dark-mode-support

分支策略配置

# .claudecode/branch-config.yml
strategy:
main: main
develop: develop
release: release/*
hotfix: hotfix/*
feature: feature/*

naming:
feature: "feature/{ticket}-{description}"
bugfix: "fix/{ticket}-{description}"
hotfix: "hotfix/{version}-{description}"
release: "release/{version}"

workflows:
feature:
from: develop
merge_to: develop
delete_after_merge: true
hotfix:
from: main
merge_to: [main, develop]
delete_after_merge: true

2.4 Git Hooks 集成

Pre-commit Hook

#!/bin/bash
# .git/hooks/pre-commit

# Claude Code 自动检查
claude-code check –staged

# 运行测试
claude-code test –affected

# 代码格式化
claude-code format –staged

Commit-msg Hook

#!/bin/bash
# .git/hooks/commit-msg

# 验证提交消息格式
claude-code validate-commit-msg "$1"

# 如果消息格式不正确，生成建议
if [ $? -ne 0 ]; then
echo "提交消息格式不正确。建议："
claude-code suggest-commit-msg
exit 1
fi

Pre-push Hook

#!/bin/bash
# .git/hooks/pre-push

# 运行完整测试套件
claude-code test –all

# 安全扫描
claude-code security-scan

# 检查依赖漏洞
claude-code audit-dependencies

3. CI/CD 集成

3.1 GitHub Actions 集成

基础工作流

# .github/workflows/claude-code.yml
name: Claude Code CI

on:
push:
branches: [main, develop]
pull_request:
branches: [main]

jobs:
analyze:
runs-on: ubuntu–latest
steps:
– uses: actions/checkout@v4

– name: Setup Claude Code
uses: anthropic/setup–claude–code@v1
with:
api-key: ${{ secrets.CLAUDE_API_KEY }}

– name: Code Analysis
run: |
claude-code analyze \\
–output sarif \\
–output-path results.sarif

– name: Upload SARIF
uses: github/codeql–action/upload–sarif@v2
with:
sarif_file: results.sarif

自动化代码审查

# .github/workflows/claude-review.yml
name: Claude Code Review

on:
pull_request:
types: [opened, synchronize]

jobs:
review:
runs-on: ubuntu–latest
permissions:
pull-requests: write
contents: read

steps:
– uses: actions/checkout@v4
with:
fetch-depth: 0

– name: Setup Claude Code
uses: anthropic/setup–claude–code@v1
with:
api-key: ${{ secrets.CLAUDE_API_KEY }}

– name: Review PR
id: review
run: |
REVIEW=$(claude-code review-pr \\
–base ${{ github.base_ref }} \\
–head ${{ github.head_ref }} \\
–format github-comment)
echo "review<<EOF" >> $GITHUB_OUTPUT
echo "$REVIEW" >> $GITHUB_OUTPUT
echo "EOF" >> $GITHUB_OUTPUT

– name: Post Review Comment
uses: actions/github–script@v7
with:
script: |
github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
body: `${{ steps.review.outputs.review }}`
})

自动修复工作流

# .github/workflows/claude-autofix.yml
name: Claude Auto Fix

on:
issues:
types: [labeled]

jobs:
autofix:
if: github.event.label.name == 'claude–autofix'
runs-on: ubuntu–latest
permissions:
contents: write
pull-requests: write

steps:
– uses: actions/checkout@v4

– name: Setup Claude Code
uses: anthropic/setup–claude–code@v1
with:
api-key: ${{ secrets.CLAUDE_API_KEY }}

– name: Analyze Issue
id: analyze
run: |
FIX=$(claude-code analyze-issue \\
–issue ${{ github.event.issue.number }} \\
–suggest-fix)
echo "fix<<EOF" >> $GITHUB_OUTPUT
echo "$FIX" >> $GITHUB_OUTPUT
echo "EOF" >> $GITHUB_OUTPUT

– name: Create Fix Branch
run: |
git config user.name "Claude Code Bot"
git config user.email "claude-code@example.com"
git checkout -b fix/issue-${{ github.event.issue.number }}

– name: Apply Fix
run: |
claude-code apply-fix "${{ steps.analyze.outputs.fix }}"

– name: Create Pull Request
run: |
git add .
git commit -m "fix: auto-fix for issue #${{ github.event.issue.number }}"
git push origin fix/issue-${{ github.event.issue.number }}

gh pr create \\
–title "Auto-fix: Issue #${{ github.event.issue.number }}" \\
––body "Automated fix generated by Claude Code" \\
––base main

3.2 GitLab CI 集成

# .gitlab-ci.yml
stages:
– analyze
– test
– deploy

claude-analyze:
stage: analyze
image: node:18
before_script:
– npm install –g @anthropic/claude–code
script:
– claude–code analyze ––output gitlab ––output–path claude–report.json
artifacts:
reports:
codequality: claude–report.json
expire_in: 1 week
only:
– merge_requests
– main

claude-review:
stage: analyze
image: node:18
before_script:
– npm install –g @anthropic/claude–code
script:
– claude–code review–mr ––output review.md
artifacts:
paths:
– review.md
only:
– merge_requests

claude-security:
stage: analyze
image: node:18
before_script:
– npm install –g @anthropic/claude–code
script:
– claude–code security–scan ––output security–report.json
artifacts:
reports:
sast: security–report.json
only:
– main
– develop

3.3 Jenkins 集成

// Jenkinsfile
pipeline {
agent any

environment {
CLAUDE_API_KEY = credentials('claude-api-key')
}

stages {
stage('Checkout') {
steps {
checkout scm
}
}

stage('Setup') {
steps {
sh 'npm install -g @anthropic/claude-code'
}
}

stage('Claude Analyze') {
steps {
sh '''
claude-code analyze \\
–output junit \\
–output-path claude-analysis.xml
'''
}
post {
always {
junit 'claude-analysis.xml'
}
}
}

stage('Claude Review') {
when {
changeRequest()
}
steps {
sh '''
claude-code review-pr \\
–target-branch ${CHANGE_TARGET} \\
–source-branch ${BRANCH_NAME}
'''
}
}

stage('Security Scan') {
steps {
sh 'claude-code security-scan'
}
}
}

post {
always {
archiveArtifacts artifacts: 'claude-*.xml', fingerprint: true
}
}
}

3.4 CI/CD 最佳实践

分层检查策略

# 分层配置
# .claudecode/ci-config.yml
layers:
quick:
trigger: pre–commit
checks:
– syntax
– formatting
– imports
timeout: 30s

standard:
trigger: pre–push
checks:
– lint
– types
– unit–tests
timeout: 5m

comprehensive:
trigger: ci
checks:
– security
– complexity
– integration–tests
– coverage
timeout: 30m

增量分析配置

# 增量分析配置
incremental:
enabled: true
base-branch: main
changed-files-only: true
related-context-depth: 3

cache:
enabled: true
ttl: 24h
key-template: "claude-${branch}-${hash}"

4. API 集成

4.1 Claude API 基础

API 认证

# 设置 API 密钥
export ANTHROPIC_API_KEY="your-api-key"

# 或在配置文件中设置
claude-code config set api.key $ANTHROPIC_API_KEY

基础 API 调用

# Python SDK 示例
import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "解释这段代码的作用：\\n" + code
}
]
)

print(message.content)

// Node.js SDK 示例
import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

const message = await anthropic.messages.create({
model: 'claude-3-5-sonnet-20241022',
max_tokens: 4096,
messages: [
{
role: 'user',
content: `重构这段代码以提高可读性：\\n${code}`
}
]
});

console.log(message.content);

4.2 自定义工具集成

定义自定义工具

// tools/database.ts
import { Tool } from '@anthropic/claude-code';

export const databaseTool: Tool = {
name: 'query_database',
description: '执行数据库查询并返回结果',
parameters: {
type: 'object',
properties: {
query: {
type: 'string',
description: 'SQL 查询语句'
},
database: {
type: 'string',
enum: ['main', 'analytics', 'logs'],
description: '目标数据库'
}
},
required: ['query']
},

async execute({ query, database = 'main' }) {
const db = getDatabaseConnection(database);
const result = await db.query(query);
return JSON.stringify(result, null, 2);
}
};

注册工具

// claudecode.config.ts
import { defineConfig } from '@anthropic/claude-code';
import { databaseTool } from './tools/database';
import { gitTool } from './tools/git';

export default defineConfig({
tools: [
databaseTool,
gitTool,
// 内置工具
'file_operations',
'code_analysis',
'shell_execution'
],

toolPermissions: {
databaseTool: {
allowedDatabases: ['main', 'analytics'],
maxRows: 1000,
timeout: 30000
}
}
});

4.3 MCP (Model Context Protocol) 集成

MCP 服务器配置

// .claudecode/mcp-servers.json
{
"mcpServers": {
"database": {
"command": "node",
"args": ["./mcp-servers/database-server.js"],
"env": {
"DB_HOST": "localhost",
"DB_PORT": "5432"
}
},
"kubernetes": {
"command": "kubectl-mcp-server",
"args": ["–namespace", "default"]
},
"aws": {
"command": "aws-mcp-server",
"env": {
"AWS_PROFILE": "development"
}
}
}
}

实现 MCP 服务器

// mcp-servers/database-server.ts
import { Server } from '@modelcontextprotocol/sdk';
import { DatabaseClient } from './db-client';

const server = new Server({
name: 'database-mcp-server',
version: '1.0.0'
}, {
capabilities: {
tools: true,
resources: true
}
});

// 注册资源
server.resources.register({
name: 'database_schema',
description: '数据库结构信息',
async read() {
const schema = await DatabaseClient.getSchema();
return { content: JSON.stringify(schema, null, 2) };
}
});

// 注册工具
server.tools.register({
name: 'execute_query',
description: '执行 SQL 查询',
parameters: {
type: 'object',
properties: {
query: { type: 'string' }
},
required: ['query']
},
async execute({ query }: { query: string }) {
const result = await DatabaseClient.query(query);
return { content: JSON.stringify(result, null, 2) };
}
});

server.start();

4.4 Webhook 集成

配置 Webhook

# .claudecode/webhooks.yml
webhooks:
– name: slack–notification
trigger: code–review–complete
url: https://hooks.slack.com/services/XXX
method: POST
headers:
Content-Type: application/json
template: |
{
"text": "代码审查完成",
"attachments": [{
"color": "{{#if issues}}warning{{else}}good{{/if}}",
"fields": [{
"title": "文件数量",
"value": "{{fileCount}}",
"short": true
}, {
"title": "问题数量",
"value": "{{issues.length}}",
"short": true
}]
}]
}

– name: jira–update
trigger: pr–merged
url: https://your–company.atlassian.net/rest/api/3/issue/{{issueKey}}/transitions
method: POST
headers:
Authorization: Bearer ${JIRA_TOKEN}
template: |
{
"transition": {
"id": "31"
}
}

处理 Webhook 事件

// webhook-handler.ts
import { WebhookHandler } from '@anthropic/claude-code';

const handler = new WebhookHandler({
port: 3000,
path: '/webhooks/claude-code'
});

handler.on('code-review-complete', async (event) => {
const { fileCount, issues, suggestions } = event.data;

// 发送通知
await sendSlackNotification({
text: `代码审查完成：${fileCount} 个文件`,
issues: issues.length
});

// 更新状态
await updatePRStatus({
status: issues.length > 0 ? 'changes_requested' : 'approved'
});
});

handler.on('pr-merged', async (event) => {
const { branch, issueKeys, author } = event.data;

// 更新 Jira
for (const issueKey of issueKeys) {
await jira.transition(issueKey, 'Done');
}

// 发送感谢消息
await slack.sendDirectMessage(author, '感谢您的贡献！');
});

handler.start();

4.5 API 限流与错误处理

实现重试机制

// api-client.ts
import { ClaudeClient } from '@anthropic/claude-code';
import { retry } from 'exponential-backoff';

class RobustClaudeClient {
private client: ClaudeClient;

constructor() {
this.client = new ClaudeClient({
apiKey: process.env.ANTHROPIC_API_KEY,
maxRetries: 3,
retryDelay: (attempt) => Math.pow(2, attempt) * 1000
});
}

async analyzeCode(code: string) {
return retry(
async () => {
try {
return await this.client.analyze(code);
} catch (error) {
if (error.status === 429) {
// 速率限制，等待后重试
const retryAfter = error.headers['retry-after'];
await sleep(parseInt(retryAfter) * 1000);
throw error; // 触发重试
}
throw error; // 其他错误直接抛出
}
},
{
numOfAttempts: 5,
startingDelay: 1000,
timeMultiple: 2
}
);
}

// 批量处理队列
async batchProcess(items: string[], batchSize = 10) {
const results = [];

for (let i = 0; i < items.length; i += batchSize) {
const batch = items.slice(i, i + batchSize);
const batchResults = await Promise.all(
batch.map(item => this.analyzeCode(item))
);
results.push(…batchResults);

// 批次间延迟，避免速率限制
if (i + batchSize < items.length) {
await sleep(1000);
}
}

return results;
}
}

5. 自定义扩展开发

5.1 扩展架构概述

Claude Code 的扩展系统采用模块化设计：

claude-code-extension/
├── manifest.json # 扩展清单
├── src/
│ ├── index.ts # 入口文件
│ ├── commands/ # 命令定义
│ ├── tools/ # 工具定义
│ ├── providers/ # 上下文提供者
│ └── hooks/ # 生命周期钩子
├── tests/
│ └── extension.test.ts
└── package.json

5.2 创建基础扩展

扩展清单

// manifest.json
{
"name": "my-claude-extension",
"version": "1.0.0",
"displayName": "My Claude Extension",
"description": "自定义 Claude Code 扩展",
"author": "Your Name",
"license": "MIT",
"engines": {
"claude-code": ">=1.0.0"
},
"categories": ["productivity", "integration"],
"activationEvents": [
"onCommand:myExtension.hello",
"onLanguage:typescript",
"onFile:*.spec.ts"
],
"main": "./dist/index.js",
"contributes": {
"commands": [
{
"command": "myExtension.hello",
"title": "Say Hello",
"category": "My Extension"
},
{
"command": "myExtension.analyze",
"title": "Analyze Code",
"category": "My Extension"
}
],
"tools": [
{
"name": "weather_check",
"description": "获取天气信息"
}
]
}
}

扩展入口

// src/index.ts
import { Extension, commands, tools, providers } from '@anthropic/claude-code';
import { helloCommand } from './commands/hello';
import { analyzeCommand } from './commands/analyze';
import { weatherTool } from './tools/weather';
import { projectProvider } from './providers/project';

export function activate(context: ExtensionContext) {
// 注册命令
context.subscriptions.push(
commands.registerCommand('myExtension.hello', helloCommand),
commands.registerCommand('myExtension.analyze', analyzeCommand)
);

// 注册工具
context.subscriptions.push(
tools.registerTool(weatherTool)
);

// 注册上下文提供者
context.subscriptions.push(
providers.registerContextProvider(projectProvider)
);

console.log('My Claude Extension 已激活');
}

export function deactivate() {
console.log('My Claude Extension 已停用');
}

5.3 开发自定义命令

命令定义

// src/commands/analyze.ts
import { commands, window, ProgressLocation } from '@anthropic/claude-code';

interface AnalyzeOptions {
depth: 'shallow' | 'medium' | 'deep';
includeTests: boolean;
outputFormat: 'markdown' | 'json' | 'html';
}

export async function analyzeCommand(options: AnalyzeOptions) {
const editor = window.activeTextEditor;

if (!editor) {
window.showErrorMessage('请先打开一个文件');
return;
}

const document = editor.document;
const code = document.getText();

await window.withProgress(
{
location: ProgressLocation.Notification,
title: '正在分析代码…',
cancellable: true
},
async (progress, token) => {
progress.report({ increment: 0, message: '解析代码结构…' });

// 执行分析
const analysis = await analyzeCode(code, options, token);

if (token.isCancellationRequested) {
return;
}

progress.report({ increment: 50, message: '生成报告…' });

// 生成报告
const report = generateReport(analysis, options.outputFormat);

progress.report({ increment: 100, message: '完成' });

// 显示结果
showReport(report, options.outputFormat);
}
);
}

async function analyzeCode(
code: string,
options: AnalyzeOptions,
token: CancellationToken
): Promise<AnalysisResult> {
// 使用 Claude Code API 进行分析
const response = await claude.messages.create({
model: 'claude-3-5-sonnet',
max_tokens: 8192,
messages: [{
role: 'user',
content: `分析以下代码：

${code}

分析深度：${options.depth}
包含测试建议：${options.includeTests}

请提供：
1. 代码结构分析
2. 潜在问题
3. 改进建议
4. 复杂度评估`
}]
}, { signal: token });

return parseAnalysis(response.content);
}

带参数的命令

// src/commands/refactor.ts
import { commands, window, QuickPickItem } from '@anthropic/claude-code';

interface RefactorOption extends QuickPickItem {
value: string;
}

export async function refactorCommand() {
const editor = window.activeTextEditor;
const selection = editor?.selection;

if (!selection || selection.isEmpty) {
window.showWarningMessage('请先选择要重构的代码');
return;
}

const selectedCode = editor.document.getText(selection);

// 显示重构选项
const options: RefactorOption[] = [
{ label: '$(symbol-method) 提取函数', value: 'extract_function', description: '将选中的代码提取为独立函数' },
{ label: '$(symbol-variable) 提取变量', value: 'extract_variable', description: '将表达式提取为变量' },
{ label: '$(symbol-interface) 提取接口', value: 'extract_interface', description: '从类型中提取接口' },
{ label: '$(sync~spin) 简化代码', value: 'simplify', description: '简化复杂的代码逻辑' },
{ label: '$(optimize) 性能优化', value: 'optimize', description: '优化性能瓶颈' }
];

const selected = await window.showQuickPick(options, {
placeHolder: '选择重构类型'
});

if (!selected) return;

// 执行重构
const refactoredCode = await performRefactor(selectedCode, selected.value);

// 应用更改
await editor.edit(editBuilder => {
editBuilder.replace(selection, refactoredCode);
});

window.showInformationMessage(`重构完成：${selected.label}`);
}

5.4 开发自定义工具

工具定义

// src/tools/weather.ts
import { Tool, ToolResult } from '@anthropic/claude-code';

interface WeatherParams {
location: string;
unit?: 'celsius' | 'fahrenheit';
days?: number;
}

export const weatherTool: Tool<WeatherParams> = {
name: 'get_weather',
description: '获取指定位置的天气信息',

parameters: {
type: 'object',
properties: {
location: {
type: 'string',
description: '城市名称或坐标，如 "北京" 或 "39.9042,116.4074"'
},
unit: {
type: 'string',
enum: ['celsius', 'fahrenheit'],
default: 'celsius',
description: '温度单位'
},
days: {
type: 'number',
minimum: 1,
maximum: 7,
default: 1,
description: '预报天数'
}
},
required: ['location']
},

async execute(params: WeatherParams): Promise<ToolResult> {
const { location, unit = 'celsius', days = 1 } = params;

try {
// 调用天气 API
const response = await fetch(
`https://api.weather.example/v1/forecast?location=${encodeURIComponent(location)}&days=${days}`
);

if (!response.ok) {
throw new Error(`天气 API 错误: ${response.status}`);
}

const data = await response.json();

// 格式化结果
const weatherInfo = formatWeatherData(data, unit);

return {
success: true,
data: weatherInfo
};
} catch (error) {
return {
success: false,
error: error.message
};
}
}
};

function formatWeatherData(data: any, unit: string): string {
const tempUnit = unit === 'celsius' ? '°C' : '°F';

return `
📍 位置: ${data.location.name}
🌡️ 当前温度: ${data.current.temp}${tempUnit}
🌤️ 天气: ${data.current.condition}
💨 风速: ${data.current.wind} km/h
💧 湿度: ${data.current.humidity}%
${data.forecast ? `\\n📅 预报:\\n${formatForecast(data.forecast, tempUnit)}` : ''}
`.trim();
}

带权限控制的工具

// src/tools/database.ts
import { Tool, ToolResult, Permissions } from '@anthropic/claude-code';

export const databaseTool: Tool = {
name: 'query_database',
description: '执行数据库查询',

parameters: {
type: 'object',
properties: {
query: { type: 'string', description: 'SQL 查询语句' },
database: {
type: 'string',
enum: ['main', 'analytics'],
description: '目标数据库'
}
},
required: ['query']
},

// 权限配置
permissions: {
requiresApproval: true,
riskLevel: 'high',
auditLog: true,
rateLimit: {
maxRequests: 100,
windowMs: 60000
}
},

async execute(params, context): Promise<ToolResult> {
const { query, database = 'main' } = params;

// 权限检查
if (!context.user.roles.includes('database_reader')) {
return {
success: false,
error: '权限不足：需要 database_reader 角色'
};
}

// SQL 注入检查
if (containsSQLInjection(query)) {
return {
success: false,
error: '检测到潜在的 SQL 注入，查询被拒绝'
};
}

// 只读检查
if (!isReadOnlyQuery(query)) {
return {
success: false,
error: '仅允许执行只读查询 (SELECT, SHOW, DESCRIBE)'
};
}

try {
const connection = getConnection(database);
const result = await connection.query(query);

// 记录审计日志
await logAudit({
user: context.user.id,
action: 'database_query',
query,
database,
timestamp: new Date()
});

return {
success: true,
data: JSON.stringify(result, null, 2)
};
} catch (error) {
return {
success: false,
error: `查询执行失败: ${error.message}`
};
}
}
};

5.5 上下文提供者

项目上下文提供者

// src/providers/project.ts
import { ContextProvider, ContextResult } from '@anthropic/claude-code';

export const projectProvider: ContextProvider = {
name: 'project-context',
description: '提供项目相关的上下文信息',

triggers: {
filePatterns: ['**/*.{ts,tsx,js,jsx}'],
commands: ['analyze', 'refactor', 'generate']
},

async provide(context: ProviderContext): Promise<ContextResult> {
const { workspace, activeFile } = context;

// 收集项目信息
const projectInfo = await collectProjectInfo(workspace);

// 分析代码依赖
const dependencies = await analyzeDependencies(activeFile);

// 获取相关文件
const relatedFiles = await findRelatedFiles(activeFile);

return {
context: `
## 项目上下文

### 基本信息
– 名称: ${projectInfo.name}
– 版本: ${projectInfo.version}
– 语言: ${projectInfo.language}
– 框架: ${projectInfo.framework}

### 当前文件
– 路径: ${activeFile.path}
– 类型: ${activeFile.type}
– 依赖: ${dependencies.join(', ')}

### 相关文件
${relatedFiles.map(f => `– ${f.path}: ${f.description}`).join('\\n')}

### 编码规范
${projectInfo.styleGuide}
`.trim(),
metadata: {
language: projectInfo.language,
framework: projectInfo.framework
}
};
}
};

async function collectProjectInfo(workspace: Workspace) {
// 读取 package.json
const packageJson = await workspace.readFile('package.json');

// 读取 tsconfig.json
const tsconfig = await workspace.readFile('tsconfig.json');

// 读取 ESLint 配置
const eslintConfig = await workspace.readFile('.eslintrc.js');

return {
name: packageJson.name,
version: packageJson.version,
language: tsconfig ? 'TypeScript' : 'JavaScript',
framework: detectFramework(packageJson.dependencies),
styleGuide: extractStyleGuide(eslintConfig)
};
}

5.6 生命周期钩子

// src/hooks/index.ts
import { ExtensionContext, window } from '@anthropic/claude-code';

export function registerHooks(context: ExtensionContext) {
// 文件保存时触发
context.subscriptions.push(
window.onDidSaveTextDocument(async (document) => {
// 自动格式化
if (document.languageId === 'typescript') {
await formatDocument(document);
}

// 自动添加导入
await organizeImports(document);

// 保存时分析
await quickAnalysis(document);
})
);

// 文件打开时触发
context.subscriptions.push(
window.onDidOpenTextDocument(async (document) => {
// 加载相关上下文
await loadRelatedContext(document);

// 显示文档概览
if (document.uri.scheme === 'file') {
showDocumentOverview(document);
}
})
);

// 编辑器切换时触发
context.subscriptions.push(
window.onDidChangeActiveTextEditor(async (editor) => {
if (editor) {
// 更新状态栏
updateStatusBar(editor.document);

// 加载文件特定配置
await loadFileConfig(editor.document);
}
})
);

// 工作区变更时触发
context.subscriptions.push(
workspace.onDidChangeWorkspaceFolders((event) => {
// 重新索引项目
reindexWorkspace(event);
})
);
}

5.7 扩展配置

配置定义

// package.json
{
"contributes": {
"configuration": {
"title": "My Extension",
"properties": {
"myExtension.enableAutoAnalysis": {
"type": "boolean",
"default": true,
"description": "启用自动代码分析"
},
"myExtension.analysisDepth": {
"type": "string",
"enum": ["shallow", "medium", "deep"],
"default": "medium",
"description": "分析深度"
},
"myExtension.maxTokens": {
"type": "number",
"default": 4096,
"minimum": 1024,
"maximum": 32768,
"description": "每次请求的最大 token 数"
},
"myExtension.apiEndpoint": {
"type": "string",
"default": "https://api.anthropic.com",
"description": "API 端点"
}
}
}
}
}

读取配置

// src/config.ts
import { workspace } from '@anthropic/claude-code';

export interface ExtensionConfig {
enableAutoAnalysis: boolean;
analysisDepth: 'shallow' | 'medium' | 'deep';
maxTokens: number;
apiEndpoint: string;
}

export function getConfig(): ExtensionConfig {
const config = workspace.getConfiguration('myExtension');

return {
enableAutoAnalysis: config.get('enableAutoAnalysis', true),
analysisDepth: config.get('analysisDepth', 'medium'),
maxTokens: config.get('maxTokens', 4096),
apiEndpoint: config.get('apiEndpoint', 'https://api.anthropic.com')
};
}

// 监听配置变化
export function onConfigChange(callback: (config: ExtensionConfig) => void) {
return workspace.onDidChangeConfiguration((event) => {
if (event.affectsConfiguration('myExtension')) {
callback(getConfig());
}
});
}

5.8 测试扩展

// tests/extension.test.ts
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { activate, deactivate } from '../src/index';
import { createTestContext, mockDocument } from '@anthropic/claude-code/testing';

describe('My Extension', () => {
let context: ExtensionContext;

beforeEach(async () => {
context = createTestContext();
await activate(context);
});

afterEach(async () => {
await deactivate();
context.dispose();
});

describe('Commands', () => {
it('should register hello command', () => {
const command = context.commands.find(c => c.id === 'myExtension.hello');
expect(command).toBeDefined();
});

it('should execute hello command', async () => {
const result = await commands.executeCommand('myExtension.hello');
expect(result).toBe('Hello from My Extension!');
});

it('should analyze code correctly', async () => {
const document = mockDocument({
language: 'typescript',
content: 'const x = 1 + 2;'
});

const result = await commands.executeCommand('myExtension.analyze', {
document,
depth: 'shallow'
});

expect(result.issues).toBeDefined();
expect(result.suggestions).toBeInstanceOf(Array);
});
});

describe('Tools', () => {
it('should execute weather tool', async () => {
const result = await tools.execute('get_weather', {
location: 'Beijing',
unit: 'celsius'
});

expect(result.success).toBe(true);
expect(result.data).toContain('Beijing');
});
});

describe('Providers', () => {
it('should provide project context', async () => {
const context = await providers.getContext('project-context', {
workspace: mockWorkspace(),
activeFile: mockFile('src/index.ts')
});

expect(context).toBeDefined();
expect(context.metadata.language).toBe('TypeScript');
});
});
});

5.9 发布扩展

打包扩展

# 构建扩展
npm run build

# 打包为 .vsix 文件
claude-code package

# 或使用 npm
npx @anthropic/claude-code-cli package

发布到市场

# 登录到市场
claude-code login

# 发布扩展
claude-code publish

# 发布特定版本
claude-code publish –version 1.2.0

扩展清单

# README.md

# My Claude Extension

## 功能特性

– ✨ 自动代码分析
– 🔄 智能重构建议
– 🌐 天气信息查询
– 📊 项目上下文感知

## 安装

```bash
claude-code install my-extension

配置

在 .claudecode/settings.json 中添加：

{
"myExtension.enableAutoAnalysis": true,
"myExtension.analysisDepth": "medium"
}

使用

• Cmd+Shift+A: 分析当前文件
• Cmd+Shift+R: 重构选中的代码

贡献

欢迎提交 Issue 和 Pull Request！

许可证

MIT

—

## 总结

Claude Code 的集成与扩展能力使其不仅仅是一个代码助手，而是一个可定制的开发平台。通过：

1. **IDE 集成**：深度融入开发环境，提供无缝的编码体验
2. **Git 工作流集成**：自动化代码审查、提交消息生成等日常工作
3. **CI/CD 集成**：在持续集成流程中发挥 AI 的力量
4. **API 集成**：与其他工具和服务无缝对接
5. **自定义扩展开发**：根据团队需求打造专属功能

你可以将 Claude Code 打造成最适合你工作流程的 AI 助手，大幅提升开发效率和代码质量。

—

## 相关资源

– [Claude Code 官方文档](https://docs.anthropic.com/claude-code)
– [扩展开发指南](https://docs.anthropic.com/claude-code/extensions)
– [API 参考](https://docs.anthropic.com/api)
– [GitHub 示例仓库](https://github.com/anthropics/claude-code-examples)
– [社区论坛](https://community.anthropic.com)