# 示例：计算 Token 数量
def count_tokens(text, model="gpt-3.5-turbo"):
    """计算文本的Token数量"""
    import tiktoken
    encoding = tiktoken.encoding_for_model(model)
    return len(encoding.encode(text))

# 示例文本
text = "Hello, world! This is a test."
token_count = count_tokens(text)
print(f"Token数量: {token_count}")

// 搜索工具示例
async function codebase_search(query, options = {}) {
  // 参数说明
  const params = {
    query: "搜索关键词",           // 必需：搜索查询
    max_results: 10,              // 可选：最大结果数
    file_types: ["js", "ts"],    // 可选：文件类型过滤
    include_content: true        // 可选：是否包含内容片段
  };
  
  // 执行搜索
  const results = await searchAPI(params);
  return results;
}

# 编辑工具示例
edit_file --path="src/main.js" \
  --old_str="function oldName()" \
  --new_str="function newName()"

# 运行工具示例
def run_terminal_cmd(command, cwd=None, timeout=30):
    """
    在终端中执行命令
    
    Args:
        command: 要执行的命令
        cwd: 工作目录
        timeout: 超时时间（秒）
    
    Returns:
        执行结果对象
    """
    import subprocess
    result = subprocess.run(
        command,
        shell=True,
        cwd=cwd,
        timeout=timeout,
        capture_output=True,
        text=True
    )
    return result

{
  "name": "mcp_server",
  "version": "1.0.0",
  "tools": [
    {
      "name": "search_files",
      "description": "搜索文件内容",
      "parameters": {
        "pattern": {"type": "string"},
        "file_types": {"type": "array"}
      }
    }
  ]
}

// 浏览器工具示例
async function fetch_webpage(url, options = {}) {
  const response = await fetch(url, {
    method: 'GET',
    headers: {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
  });
  
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  
  return await response.text();
}

# 向量匹配示例
import numpy as np
from sentence_transformers import SentenceTransformer

class CodeSearch:
    def __init__(self):
        self.model = SentenceTransformer('all-MiniLM-L6-v2')
        self.code_embeddings = None
        self.code_snippets = []
    
    def index_code(self, snippets):
        """索引代码片段"""
        self.code_snippets = snippets
        self.code_embeddings = self.model.encode(snippets)
    
    def search(self, query, top_k=5):
        """搜索相关代码"""
        query_embedding = self.model.encode([query])
        similarities = np.dot(self.code_embeddings, query_embedding.T)
        top_indices = np.argsort(similarities.flatten())[-top_k:][::-1]
        
        return [self.code_snippets[i] for i in top_indices]

# Merkle Tree实现
import hashlib

class MerkleNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
        self.hash = self.calculate_hash()
    
    def calculate_hash(self):
        return hashlib.sha256(self.value.encode()).hexdigest()

class MerkleTree:
    def __init__(self, values):
        self.leaves = [MerkleNode(v) for v in values]
        self.root = self.build_tree(self.leaves)
    
    def build_tree(self, nodes):
        if len(nodes) == 1:
            return nodes[0]
        
        new_level = []
        for i in range(0, len(nodes), 2):
            if i + 1 < len(nodes):
                combined = nodes[i].hash + nodes[i+1].hash
                parent = MerkleNode(combined)
                parent.left = nodes[i]
                parent.right = nodes[i+1]
            else:
                parent = nodes[i]
            new_level.append(parent)
        
        return self.build_tree(new_level)

# System Prompt
You are Claude Code, Anthropic's official CLI for Claude. You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.

# Proactiveness
You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
1. Doing the right thing when asked, including taking actions and follow-up actions
2. Not surprising the user with actions you take without asking
3. Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.

# Synthetic messages
Sometimes, the conversation will contain messages like [Request interrupted by user] or [Request interrupted by user for tool use]. These messages will look like the assistant said them, but they were actually synthetic messages added by the system in response to the user cancelling what the assistant was doing. You should not respond to these messages. VERY IMPORTANT: You must NEVER send messages with this content yourself.

# Following conventions
When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language).
- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.

# Task Management
You have access to the TodoWrite and TodoRead tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks — and that is unacceptable. It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.

# Doing tasks
The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks, the following steps are recommended:

# Tool usage policy
- When doing file search, prefer to use the Task tool in order to reduce context usage.
- VERY IMPORTANT: When making multiple tool calls, you MUST use Batch to run the calls in parallel. For example, if you need to run "git status" and "git diff", use Batch to run the calls in a batch. Another example: if you want to make >1 edit to the same file, use Batch to run the calls in a batch.
- You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless the user asks for detail.

Here is useful information about the environment you are running in:

<env>
Working directory: /Users/xxx/Projects/xxx
Is directory a git repo: No
Platform: macos
OS Version: XX
Today's date: XX/XX/2025
Model: someModel
</env>

<context name="directoryStructure">
Below is a snapshot of this project's file structure at the start of the conversation. This snapshot will NOT update during the conversation. It skips over .gitignore patterns.
- /Users/xxx/Projects/xxx/
- CLAUDE.md
- SomeModule/
- SomeFiles
- README.md
- ...
</context>

Generate a file named AGENTS.md that serves as a contributor guide for this repository.

▌ Your goal is to produce a clear, concise, and well-structured document with descriptive headings and actionable explanations for each section.
▌ Follow the outline below, but adapt as needed — add sections if relevant, and omit those that do not apply to this project.
▌
▌ Document Requirements
▌
▌ - Title the document "Repository Guidelines".
▌ - Use Markdown headings (#, ##, etc.) for structure.
▌ - Keep the document concise. 200-400 words is optimal.
▌ - Keep explanations short, direct, and specific to this repository.
▌ - Provide examples where helpful (commands, directory paths, naming patterns).
▌ - Maintain a professional, instructional tone.
▌
▌ Recommended Sections
▌
▌ Project Structure & Module Organization
▌
▌ - Outline the project structure, including where the source code, tests, and assets are located.
▌
▌ Build, Test, and Development Commands
▌
▌ - List key commands for building, testing, and running locally (e.g., npm test, make build).
▌ - Briefly explain what each command does.
▌
▌ Coding Style & Naming Conventions
▌
▌ - Specify indentation rules, language-specific style preferences, and naming patterns.
▌ - Include any formatting or linting tools used.
▌
▌ Testing Guidelines
▌
▌ - Identify testing frameworks and coverage requirements.
▌ - State test naming conventions and how to run tests.
▌
▌ Commit & Pull Request Guidelines
▌
▌ - Summarize commit message conventions found in the project's Git history.
▌ - Outline pull request requirements (descriptions, linked issues, screenshots, etc.).
▌
▌ (Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.

讲解一下这个项目的每个module都是用来做什么的，并且给出包依赖关系图。

我希望实现一个「什么什么」功能，需要修改的部分包括「这里」和「那里」，我的代码放在哪个包/目录下比较合适？仔细分析项目结构，并给出你的理由。

我在找「某个某个」功能的实现，请帮我在仓库里搜寻，并给出它的核心具体代码位置和片段，并附上简洁的说明。