MonkeyCode 与开源生态集成：打造 AI 编程的无限可能
引言
"独木不成林，单弦不成音。"
MonkeyCode 从诞生之初就秉持深度融入开源生态的理念——我们不造孤岛，而是成为连接点。通过与 GitHub、VS Code、Docker、Kubernetes、LangChain 等数百个开源项目的无缝集成，MonkeyCode 已经成为 AI 编程领域最开放、最可扩展的平台之一。
本文将全面介绍 MonkeyCode 的开源生态集成能力——从 IDE 插件到 MCP 协议，从模型适配层到工具链编排，展示如何让 AI 编程助手与你现有的技术栈完美融合。
🎯 核心信息
- GitHub 仓库: https://github.com/monkeycode-ai/monkeycode
- npm 包:
@monkeycode/core@monkeycode/cli@monkeycode/vscode- 欢迎提交 Issue: https://github.com/monkeycode-ai/monkeycode/issues
- 开源协议: Apache License 2.0
一、MonkeyCode 开源生态全景图
1.1 生态架构总览
┌─────────────────────────────────────────────────────────────────┐
│ MonkeyCode 开源生态架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ IDE 集成层 │ │ CLI 工具链 │ │ API/SDK 层 │ │
│ │ │ │ │ │ │ │
│ │ • VSCode │ │ • monkeycode │ │ • REST API │ │
│ │ • JetBrains │ │ CLI │ │ • SDK (TS) │ │
│ │ • Vim/Neovim│ │ • Docker │ │ • WebSocket │ │
│ │ • Emacs │ │ • K8s Operator│ │ • gRPC │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └────────────────┼────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ MonkeyCode Core Engine │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Prompt │ │ Context │ │ Model │ │ │
│ │ │ Engine │ │ Manager │ │ Adapter │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └──────────────────────┬─────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 模型与数据层 │ │
│ │ │ │
│ │ OpenAI │ Claude │ Local LLM │ Custom │ │
│ │ PG │ Redis │ Vector DB │ File System │ │
│ └──────────────────────────────────────────────┘ │
│ │
│ ═════════════════════════════════════════════ │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ MCP 协议 │ │ LangChain│ │ OpenAI │ │ Git 集成 │ │
│ │ Server │ │ 集成 │ │ Plugins │ │ 工作流 │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
1.2 核心开源包一览
| 包名 | 版本 | 说明 | 周下载量 | 许可证 |
|---|---|---|---|---|
@monkeycode/core |
v4.2.1 | 核心引擎（Prompt/Context/Model） | 85K+ | Apache 2.0 |
@monkeycode/cli |
v4.2.1 | 命令行工具 | 42K+ | Apache 2.0 |
@monkeycode/vscode |
v4.2.1 | VS Code 扩展 | 120K+ | Apache 2.0 |
@monkeycode/jetbrains |
v4.2.1 | JetBrains 插件 | 28K+ | Apache 2.0 |
@monkeycode/mcp-server |
v4.2.1 | MCP 协议服务端 | 15K+ | Apache 2.0 |
@monkeycode/langchain |
v4.2.1 | LangChain 集成 | 22K+ | Apache 2.0 |
@monkeycode/docker |
v4.2.1 | Docker 镜像 & Compose | 35K+ | Apache 2.0 |
@monkeycode/sdk-python |
v4.2.1 | Python SDK | 18K+ | Apache 2.0 |
@monkeycode/sdk-go |
v4.2.1 | Go SDK | 8K+ | Apache 2.0 |
二、MCP（Model Context Protocol）集成
2.1 什么是 MCP？
MCP（Model Context Protocol） 是 Anthropic 推出的开放协议，允许 AI 模型通过标准化的方式连接外部工具和数据源。MonkeyCode 是最早支持 MCP 的 AI 编程平台之一。
// ===== MonkeyCode MCP Server 实现 =====
/**
* MonkeyCode MCP Server — 让任何支持 MCP 的 AI 客户端都能使用 MonkeyCode 的能力
*
* 支持的客户端：
* - Claude Desktop
* - Cursor
* - Windsurf
* - VS Code (with MCP extension)
* - 自定义 MCP Client
*/
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from 'zod';
class MonkeyCodeMCPServer {
private server: McpServer;
private monkeycode: MonkeyCodeClient;
constructor(apiKey: string) {
this.monkeycode = new MonkeyCodeClient({ apiKey });
this.server = new McpServer({
name: 'monkeycode',
version: '4.2.1',
});
this.registerTools();
this.registerResources();
this.registerPrompts();
}
/**
* 注册 MCP Tools（AI 可调用的工具）
*/
private registerTools(): void {
// ===== Tool 1: 代码补全 =====
this.server.tool(
'complete_code',
'使用 AI 补全代码，支持多种编程语言和上下文理解',
{
code: z.string().describe('需要补全的代码片段或光标前的代码'),
language: z.string().describe('编程语言，如 typescript, python, go 等'),
cursor_position: z.number().optional().describe('光标位置（字符偏移）'),
file_path: z.string().optional().describe('文件路径，用于获取更多上下文'),
},
async ({ code, language, cursor_position, file_path }) => {
const result = await this.monkeycode.complete({
code,
language,
cursorPosition: cursor_position,
filePath: file_path,
maxTokens: 512,
});
return {
content: [{
type: 'text' as const,
text: JSON.stringify({
completion: result.completion,
confidence: result.confidence,
suggestions: result.alternatives,
}, null, 2),
}],
};
}
);
// ===== Tool 2: 代码解释 =====
this.server.tool(
'explain_code',
'解释代码的功能和逻辑，支持多语言输出',
{
code: z.string().describe('需要解释的代码'),
language: z.string().optional().describe('编程语言'),
output_language: z.string().default('zh-CN').describe('解释语言'),
detail_level: z.enum(['brief', 'standard', 'detailed']).default('standard'),
},
async ({ code, language, output_language, detail_level }) => {
const explanation = await this.monkeycode.explain({
code,
language,
outputLanguage: output_language,
detailLevel: detail_level,
});
return {
content: [{
type: 'text' as const,
text: `## 📖 代码解释\n\n${explanation.summary}\n\n### 详细分析\n\n${explanation.details}\n\n### 关键概念\n\n${explanation.concepts.map(c => `- **${c.name}**: ${c.description}`).join('\n')}`,
}],
};
}
);
// ===== Tool 3: 代码生成 =====
this.server.tool(
'generate_code',
'根据自然语言描述生成代码',
{
description: z.string().describe('功能描述或需求说明'),
language: z.string().describe('目标编程语言'),
framework: z.string().optional().describe('使用的框架，如 react, express, fastapi 等'),
style_guide: z.string().optional().describe('编码风格要求'),
include_tests: z.boolean().default(false).description('是否同时生成测试'),
include_comments: z.boolean().default(true).description('是否包含注释'),
},
async ({ description, language, framework, style_guide, include_tests, include_comments }) => {
const generated = await this.monkeycode.generate({
prompt: description,
language,
framework,
styleGuide: style_guide,
options: {
includeTests: include_tests,
includeComments: include_comments,
},
});
return {
content: [
{
type: 'text' as const,
text: `## ✨ 生成的 ${language} 代码\n\n\`\`\`${language}\n${generated.code}\n\`\`\`\n\n${generated.tests ? `## 🧪 测试代码\n\n\`\`\`${language}\n${generated.tests}\n\`\`\`` : ''}`,
},
...(generated.files?.map(f => ({
type: 'file' as const,
mimeType: 'text/plain',
data: f.content,
name: f.path,
})) || []),
],
};
}
);
// ===== Tool 4: 代码审查 =====
this.server.tool(
'review_code',
'对代码进行 AI 审查，发现潜在问题和改进建议',
{
code: z.string().describe('需要审查的代码'),
language: z.string().optional().describe('编程语言'),
focus_areas: z.array(z.enum([
'security', 'performance', 'readability',
'best_practices', 'bugs', 'style'
])).default(['security', 'performance', 'readability']),
severity_threshold: z.enum(['info', 'suggestion', 'minor', 'major', 'critical']).default('suggestion'),
},
async ({ code, language, focus_areas, severity_threshold }) => {
const review = await this.monkeycode.review({
code,
language,
focusAreas: focus_areas,
severityThreshold: severity_threshold,
});
const issuesText = review.issues.map((issue, i) =>
`### ${i + 1}. [${issue.severity.toUpperCase()}] ${issue.title}\n` +
`- **位置**: 行 ${issue.line}\n` +
`- **类别**: ${issue.category}\n` +
`- **描述**: ${issue.description}\n` +
`${issue.suggestion ? `- **建议**: ${issue.suggestion}` : ''}`
).join('\n\n');
return {
content: [{
type: 'text' as const,
text: `## 🔍 代码审查报告\n\n` +
`| 指标 | 数值 |\n|------|------|\n` +
`| 总问题数 | ${review.issues.length} |\n` +
`| 质量评分 | ${review.score}/100 |\n` +
`| 审查耗时 | ${review.durationMs}ms |\n\n` +
`### 发现的问题\n\n${issuesText}`,
}],
};
}
);
// ===== Tool 5: 重构建议 =====
this.server.tool(
'refactor_code',
'提供代码重构建议并自动执行重构',
{
code: z.string().describe('需要重构的代码'),
language: z.string().describe('编程语言'),
refactor_type: z.enum([
'simplify', 'optimize', 'modernize',
'modularize', 'pattern_apply'
]).describe('重构类型'),
target_pattern: z.string().optional().describe('应用的设计模式'),
},
async ({ code, language, refactor_type, target_pattern }) => {
const refactored = await this.monkeycode.refactor({
code,
language,
refactorType: refactor_type,
targetPattern: target_pattern,
});
return {
content: [
{
type: 'text' as const,
text: `## 🔧 重构结果 (${refactor_type})\n\n` +
`**变更摘要**: ${refactored.summary}\n\n` +
`### 重构后代码\n\n\`\`\`${language}\n${refactored.code}\n\`\`\``,
},
...(refactored.diff ? [{
type: 'text' as const,
text: `### 变更 Diff\n\n\`\`\`diff\n${refactored.diff}\n\`\`\``,
}] : []),
],
};
}
);
}
/**
* 注册 MCP Resources（AI 可读取的资源）
*/
private registerResources(): void {
// 项目结构资源
this.server.resource(
'project_structure',
'当前项目的目录结构和文件列表',
async () => {
const structure = await this.monkeycode.getProjectStructure();
return {
contents: [{
uri: 'project://structure',
mimeType: 'application/json',
text: JSON.stringify(structure, null, 2),
}],
};
}
);
// Git 状态资源
this.server.resource(
'git_status',
'当前 Git 仓库状态',
async () => {
const status = await this.monkeycode.getGitStatus();
return {
contents: [{
uri: 'git://status',
mimeType: 'application/json',
text: JSON.stringify(status, null, 2),
}],
};
}
);
}
/**
* 注册 MCP Prompts（预定义的提示模板）
*/
private registerPrompts(): void {
this.server.prompt(
'debug_error',
'帮助调试错误',
{
error_message: z.string().describe('错误信息'),
code_context: z.string().optional().describe('相关代码'),
stack_trace: z.string().optional().describe('堆栈跟踪'),
}
);
this.server.prompt(
'write_test',
'为指定函数编写单元测试',
{
function_code: z.string().describe('函数代码'),
test_framework: z.string().default('jest').describe('测试框架'),
coverage_target: z.number().default(80).describe('覆盖率目标'),
}
);
this.server.prompt(
'optimize_performance',
'优化代码性能',
{
code: z.string().describe('需要优化的代码'),
bottleneck_description: z.string().optional().describe('已知的性能瓶颈'),
target_improvement: z.string().optional().describe('优化目标，如 "减少50%内存"'),
}
);
}
/**
* 启动 MCP Server（stdio 模式）
*/
async start(): Promise<void> {
const transport = new StdioServerTransport();
await this.server.connect(transport);
console.log('🐵 MonkeyCode MCP Server started');
}
}
// ===== 使用方式 =====
// 在 Claude Desktop 配置中添加：
/*
{
"mcpServers": {
"monkeycode": {
"command": "npx",
"args": ["-y", "@monkeycode/mcp-server"],
"env": {
"MONKEYCODE_API_KEY": "your-api-key"
}
}
}
}
*/
三、LangChain 集成
3.1 作为 LangChain Tool 使用
# ===== Python: MonkeyCode + LangChain 集成 =====
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from monkeycode_sdk import MonkeyCodeClient
# 初始化 MonkeyCode 客户端
mc = MonkeyCodeClient(api_key="your-api-key")
# 定义 MonkeyCode 工具函数
@tool
def monkeycode_complete(code: str, language: str = "python") -> str:
"""
使用 MonkeyCode AI 进行智能代码补全。
Args:
code: 当前代码片段（光标前的代码）
language: 编程语言（默认 python）
Returns:
补全后的代码
"""
result = mc.complete(code=code, language=language)
return result.completion
@tool
def monkeycode_explain(code: str, language: str = "python") -> str:
"""
使用 MonkeyCode AI 解释代码的功能和逻辑。
Args:
code: 需要解释的代码
language: 编程语言
Returns:
代码的详细解释
"""
result = mc.explain(code=code, language=language)
return result.explanation
@tool
def monkeycode_review(code: str, language: str = "python") -> str:
"""
使用 MonkeyCode AI 审查代码质量。
Args:
code: 需要审查的代码
language: 编程语言
Returns:
审查结果和建议
"""
result = mc.review(code=code, language=language)
return format_review_result(result)
@tool
def monkeycode_generate(description: str, language: str = "python") -> str:
"""
根据描述使用 MonkeyCode AI 生成代码。
Args:
description: 功能描述
language: 目标编程语言
Returns:
生成的代码
"""
result = mc.generate(prompt=description, language=language)
return result.code
# 创建 LangChain Agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [
monkeycode_complete,
monkeycode_explain,
monkeycode_review,
monkeycode_generate,
]
agent = create_openai_tools_agent(llm, tools, prompt=PROMPT_TEMPLATE)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 使用示例
result = agent_executor.invoke({
"input": "请帮我写一个 Python 快速排序算法，然后用 MonkeyCode 审查它的性能问题"
})
print(result["output"])
3.2 自定义 Chain：AI 编程工作流
# ===== 自定义 LangChain Chain：完整的 AI 编程流水线 =====
from langchain.chains import SequentialChain
from langchain_core.prompts import ChatPromptTemplate
class AICodingPipeline:
"""基于 LangChain + MonkeyCode 的完整 AI 编程流水线"""
def __init__(self):
self.mc = MonkeyCodeClient()
self.llm = ChatOpenAI(model="gpt-4o")
def build_pipeline(self, requirement: str, language: str):
"""
构建完整的 AI 编程流水线：
需求分析 → 代码生成 → 代码审查 → 自动修复 → 测试生成 → 文档生成
"""
# Step 1: 需求分析与设计
design_prompt = ChatPromptTemplate.from_template("""
分析以下需求，输出技术设计方案：
需求：{requirement}
目标语言：{language}
请输出：
1. 功能拆解（模块/函数级别）
2. 数据结构设计
3. 关键算法选择
4. 边界情况处理
""")
design_chain = design_prompt | self.llm
# Step 2: 代码生成（使用 MonkeyCode）
generate_chain = (
lambda inputs: self.mc.generate(
prompt=inputs['design'],
language=language,
include_comments=True,
include_tests=False
)
)
# Step 3: 代码审查（使用 MonkeyCode）
review_chain = (
lambda inputs: self.mc.review(
code=inputs['code'],
language=language,
focus_areas=['security', 'performance', 'bugs']
)
)
# Step 4: 自动修复（使用 MonkeyCode）
fix_chain = (
lambda inputs: self.mc.auto_fix(
code=inputs['code'],
issues=inputs['review_issues']
)
)
# Step 5: 测试生成（使用 MonkeyCode）
test_chain = (
lambda inputs: self.mc.generate_tests(
code=inputs['fixed_code'],
language=language,
coverage_target=85
)
)
# 组合为完整流水线
pipeline = SequentialChain(
chains=[design_chain, generate_chain, review_chain, fix_chain, test_chain],
input_variables=['requirement', 'language'],
output_variables=['design', 'code', 'review_issues', 'fixed_code', 'tests'],
verbose=True
)
return pipeline
def run(self, requirement: str, language: str = "python"):
"""运行完整流水线"""
pipeline = self.build_pipeline(requirement, language)
return pipeline.invoke({"requirement": requirement, "language": language})
# 使用示例
pipeline = AICodingPipeline()
result = pipeline.run(
requirement="实现一个线程安全的 LRU 缓存，支持 TTL 过期",
language="python"
)
print("=== 设计方案 ===")
print(result['design'])
print("\n=== 生成的代码 ===")
print(result['code'])
print("\n=== 审查结果 ===")
print(result['review_issues'])
print("\n=== 修复后的代码 ===")
print(result['fixed_code'])
print("\n=== 生成的测试 ===")
print(result['tests'])
四、OpenAI Plugin / Function Calling 集成
4.1 OpenAI Function Calling 配置
// ===== MonkeyCode as OpenAI Functions =====
/**
* 将 MonkeyCode 能力封装为 OpenAI Function Calling 格式
* 可用于任何支持 function calling 的 OpenAI 兼容模型
*/
const MONKEYCODE_FUNCTIONS: OpenAIFunctionDefinition[] = [
{
name: 'monkeycode_complete',
description: '使用 AI 智能补全代码。输入当前代码和光标位置，返回补全建议。',
parameters: {
type: 'object',
properties: {
code: {
type: 'string',
description: '当前编辑的代码内容（包含光标前的所有文本）',
},
language: {
type: 'string',
description: '编程语言标识符，如 typescript, python, go, rust',
enum: ['typescript', 'javascript', 'python', 'go', 'rust', 'java', 'csharp', 'cpp'],
},
cursor_line: {
type: 'integer',
description: '光标所在行号（从 1 开始）',
},
cursor_column: {
type: 'integer',
description: '光标所在列号（从 1 开始）',
},
file_path: {
type: 'string',
description: '当前文件的路径（可选，用于获取项目上下文）',
},
},
required: ['code', 'language'],
},
},
{
name: 'monkeycode_explain',
description: '解释给定代码的功能、逻辑和工作原理。支持多语言输出。',
parameters: {
type: 'object',
properties: {
code: {
type: 'string',
description: '需要解释的代码',
},
language: {
type: 'string',
description: '代码的编程语言',
},
output_language: {
type: 'string',
description: '输出的解释语言',
default: 'zh-CN',
enum: ['zh-CN', 'en-US', 'ja-JP', 'ko-KR'],
},
},
required: ['code'],
},
},
{
name: 'monkeycode_generate',
description: '根据自然语言描述生成符合最佳实践的代码。可指定框架和风格。',
parameters: {
type: 'object',
properties: {
description: {
type: 'string',
description: '要生成的代码的功能描述',
},
language: {
type: 'string',
description: '目标编程语言',
},
framework: {
type: 'string',
description: '使用的框架（如 react, express, fastapi）',
},
include_tests: {
type: 'boolean',
description: '是否同时生成单元测试',
default: false,
},
include_docstring: {
type: 'boolean',
description: '是否包含文档字符串/注释',
default: true,
},
},
required: ['description', 'language'],
},
},
{
name: 'monkeycode_review',
description: '对代码进行全面的 AI 审查，包括安全性、性能、可读性等方面。',
parameters: {
type: 'object',
properties: {
code: {
type: 'string',
description: '需要审查的代码',
},
language: {
type: 'string',
description: '编程语言',
},
focus: {
type: 'array',
items: {
type: 'string',
enum: ['security', 'performance', 'readability', 'maintainability', 'bugs', 'style'],
},
description: '审查重点领域',
},
},
required: ['code'],
},
},
];
// ===== Function Handler =====
async function handleFunctionCall(
functionName: string,
args: Record<string, any>
): Promise<string> {
const client = new MonkeyCodeClient({ apiKey: process.env.MONKEYCODE_API_KEY! });
switch (functionName) {
case 'monkeycode_complete': {
const result = await client.complete({
code: args.code,
language: args.language,
cursorPosition: { line: args.cursor_line, column: args.cursor_column },
filePath: args.file_path,
});
return JSON.stringify(result);
}
case 'monkeycode_explain': {
const result = await client.explain({
code: args.code,
language: args.language,
outputLanguage: args.output_language || 'zh-CN',
});
return JSON.stringify(result);
}
case 'monkeycode_generate': {
const result = await client.generate({
prompt: args.description,
language: args.language,
framework: args.framework,
options: {
includeTests: args.include_tests || false,
includeComments: args.include_docstring !== false,
},
});
return JSON.stringify(result);
}
case 'monkeycode_review': {
const result = await client.review({
code: args.code,
language: args.language,
focusAreas: args.focus || ['security', 'performance', 'readability'],
});
return JSON.stringify(result);
}
default:
throw new Error(`Unknown function: ${functionName}`);
}
}
五、Git 工作流深度集成
5.1 Git Hooks 自动化
#!/bin/bash
# .githooks/pre-commit — MonkeyCode AI 增强 Pre-commit Hook
#!/bin/bash
set -e
# 获取暂存的文件
STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(ts|js|py|go|java|rs)$' || true)
if [ -z "$STAGED_FILES" ]; then
exit 0
fi
echo "🐵 MonkeyCode Pre-commit Check..."
echo ""
# 配置
MONKEYCODE_API_KEY="${MONKEYCODE_API_KEY:-}"
MAX_ISSUES=${MONKEYCODE_MAX_ISSUES:-10}
FAIL_ON_ERROR=${MONKEYCODE_FAIL_ON_ERROR:-false}
ISSUES_FOUND=0
WARNINGS_FOUND=0
for FILE in $STAGED_FILES; do
echo "📝 Checking: $FILE"
# 获取暂存的内容
CONTENT=$(git show ":$FILE")
# 调用 MonkeyCode API 进行快速检查
RESULT=$(curl -s -X POST "https://api.monkeycode.ai/v1/quick-check" \
-H "Authorization: Bearer $MONKEYCODE_API_KEY" \
-H "Content-Type: application/json" \
-d "{
\"file\": \"$FILE\",
\"content\": $(echo "$CONTENT" | jq -Rs .),
\"check_types\": [\"syntax\", \"security\", \"simple_bugs\"]
}")
# 解析结果
ERRORS=$(echo "$RESULT" | jq '.errors // []')
WARNINGS=$(echo "$RESULT" | jq '.warnings // []')
ERROR_COUNT=$(echo "$ERRORS" | jq 'length')
WARNING_COUNT=$(echo "$WARNINGS" | jq 'length')
ISSUES_FOUND=$((ISSUES_FOUND + ERROR_COUNT))
WARNINGS_FOUND=$((WARNINGS_FOUND + WARNING_COUNT))
if [ "$ERROR_COUNT" -gt 0 ]; then
echo " ❌ Found $ERROR_COUNT error(s):"
echo "$ERRORS" | jq -r '.[] | " Line \(.line): \(.message)"'
fi
if [ "$WARNING_COUNT" -gt 0 ]; then
echo " ⚠️ Found $WARNING_COUNT warning(s):"
echo "$WARNINGS" | jq -r '.[] | " Line \(.line): \(.message)"'
fi
echo ""
done
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "📊 Summary:"
echo " Errors: $ISSUES_FOUND"
echo " Warnings: $WARNINGS_FOUND"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
if [ "$ISSUES_FOUND" -gt 0 ] && [ "$FAIL_ON_ERROR" = "true" ]; then
echo ""
echo "❌ Commit blocked due to errors."
echo " Fix the errors or commit with --no-verify to bypass."
exit 1
fi
echo "✅ Pre-check passed!"
exit 0
5.2 Commit Message AI 生成
// ===== AI 生成规范的 Commit Message =====
import { execSync } from 'child_process';
import { MonkeyCodeClient } from '@monkeycode/core';
/**
* 使用 AI 分析 git diff 并生成规范的 Conventional Commit message
*/
async function generateCommitMessage(): Promise<string> {
const mc = new MonkeyCodeClient();
// 获取 git diff
const diff = execSync('git diff --cached --stat').toString();
const detailedDiff = execSync('git diff --cached').toString();
// 获取最近的 commit messages 用于风格学习
const recentMessages = execSync(
'git log --oneline -10'
).toString()
.split('\n')
.filter(Boolean);
// AI 生成 commit message
const result = await mc.generate({
prompt: `
分析以下 git diff，生成一个规范的 Conventional Commit message。
Diff 统计：
${diff}
详细变更：
${detailedDiff.substring(0, 8000)} // 限制长度避免超 token
最近的历史 commit 风格参考：
${recentMessages.join('\n')}
要求：
1. 使用 Conventional Commits 格式：type(scope): subject
2. type 可以是 feat/fix/docs/refactor/test/chore/style/ci/perf/revert
3. scope 尽量精确到受影响的模块
4. subject 不超过 72 字符，使用中文
5. 如果变更较大，在 body 中列出关键变更点
`,
language: 'markdown',
});
return result.code.trim();
}
// 使用方式：npm run commit (替代 git commit)
// package.json 中配置：
// "commit": "ts-node scripts/generate-commit.ts && git commit -e $(ts-node scripts/generate-commit.ts)"
六、Docker & Kubernetes 部署集成
6.1 Docker Compose 一键部署
# docker-compose.yml — MonkeyCode 全栈部署
version: '3.8'
services:
# ===== MonkeyCode Core Service =====
monkeycode:
image: monkeycode/server:latest
container_name: monkeycode-core
restart: unless-stopped
ports:
- "8443:8443"
environment:
- NODE_ENV=production
- PORT=8443
- DATABASE_URL=postgres://monkeycode:${DB_PASSWORD}@postgres:5432/monkeycode
- REDIS_URL=redis://redis:6379
- JWT_SECRET=${JWT_SECRET}
- OPENAI_API_KEY=${OPENAI_API_KEY}
- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
# 本地模型配置（可选）
- LOCAL_MODEL_ENABLED=${LOCAL_MODEL_ENABLED:-false}
- LOCAL_MODEL_PATH=/models
volumes:
- ./data/uploads:/app/uploads
- ./config:/app/config:ro
- model-cache:/app/.cache/models
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8443/health"]
interval: 30s
timeout: 10s
retries: 3
deploy:
resources:
limits:
memory: 4G
cpus: '2.0'
reservations:
memory: 2G
cpus: '1.0'
# ===== PostgreSQL =====
postgres:
image: postgres:16-alpine
container_name: monkeycode-db
restart: unless-stopped
environment:
POSTGRES_DB: monkeycode
POSTGRES_USER: monkeycode
POSTGRES_PASSWORD: ${DB_PASSWORD}
volumes:
- pgdata:/var/lib/postgresql/data
ports:
- "5432:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U monkeycode"]
interval: 10s
timeout: 5s
retries: 5
# ===== Redis =====
redis:
image: redis:7-alpine
container_name: monkeycode-redis
restart: unless-stopped
command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
volumes:
- redisdata:/data
ports:
- "6379:6379"
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 5
# ===== Nginx 反向代理 =====
nginx:
image: nginx:alpine
container_name: monkeycode-nginx
restart: unless-stopped
ports:
- "80:80"
- "443:443"
volumes:
- ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
- ./nginx/ssl:/etc/nginx/ssl:ro
- ./nginx/logs:/var/log/nginx
depends_on:
- monkeycode
volumes:
pgdata:
redisdata:
model-cache:
networks:
default:
name: monkeycode-network
6.2 Kubernetes Helm Chart
# charts/monkeycode/values.yaml — Kubernetes 部署配置
replicaCount: 2
image:
repository: monkeycode/server
tag: latest
pullPolicy: IfNotPresent
service:
type: ClusterIP
port: 8443
ingress:
enabled: true
className: nginx
annotations:
cert-manager.io/cluster-issuer: letsencrypt-prod
hosts:
- host: monkeycode.example.com
paths:
- path: /
pathType: Prefix
tls:
- secretName: monkeycode-tls
hosts:
- monkeycode.example.com
resources:
limits:
cpu: 2000m
memory: 4Gi
requests:
cpu: 500m
memory: 1Gi
autoscaling:
enabled: true
minReplicas: 2
maxReplicas: 10
targetCPUUtilizationPercentage: 70
targetMemoryUtilizationPercentage: 80
postgresql:
enabled: true
auth:
password: ${DB_PASSWORD}
primary:
persistence:
size: 20Gi
redis:
enabled: true
architecture: standalone
auth:
enabled: false
master:
persistence:
size: 5Gi
七、参与生态集成的帮助
我们需要的帮助
| 方向 | 说明 | 适合谁 |
|---|---|---|
| 🔌 新 IDE 支持 | Xcode、Android Studio、WebStorm 等插件开发 | 插件开发者 |
| 🤝 新框架集成 | Next.js/Nuxt/SvelteKit/Angular 专用工具链 | 全栈开发者 |
| 🐳 更多云平台 | AWS/GCP/Azure/Tencent Cloud 一键部署模板 | DevOps 工程师 |
| 📦 更多语言 SDK | Ruby/PHP/Swift/Kotlin/Dart SDK | 多语言开发者 |
| 🔗 新协议支持 | gRPC/GraphQL/WebSocket 高级接口 | 后端开发者 |
| 🧪 生态兼容性测试 | 跨版本/跨平台的集成测试 | QA 工程师 |
欢迎在 GitHub 提交 Issue 和 PR！
👉 GitHub: https://github.com/monkeycode-ai/monkeycode
👉 Discord: https://discord.gg/monkeycode
👉 提交 Issue: https://github.com/monkeycode-ai/monkeycode/issues/new?labels=integration
结语
"真正的开源不是把代码扔出来——而是构建一个任何人都可以参与、可以扩展、可以依赖的生态系统。"
MonkeyCode 的每一行代码、每一个接口、每一个协议都遵循开放原则。我们相信，只有当 AI 编程工具与整个开源生态深度融合时，才能释放出最大的价值。无论你使用什么 IDE、什么框架、什么云平台，MonkeyCode 都能找到融入的方式。
现在就探索 MonkeyCode 的开源生态吧——或者，成为生态的一部分，让我们一起构建更美好的 AI 编程未来！ 🌐✨
本文由 MonkeyCode 团队原创，采用 Apache 2.0 许可证发布。
关键词: MonkeyCode 开源生态 MCP LangChain Docker Kubernetes Git CI/CD API集成 AI编程助手 VSCode
浙公网安备 33010602011771号