Serena：基于LSP的符号级代码理解与重构工具，支持30+编程语言

serena by massgen/massgen

82 周安装量

891 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/massgen/massgen --skill serena

开发自动化代码质量

🇨🇳中文介绍

Serena：符号级代码理解

使用基于语言服务器协议（LSP）的类 IDE 语义分析，在符号级别导航和操作代码。

如何访问 Serena

您可能通过以下一种或两种方式获得 Serena：

选项 1：直接 MCP 工具（如果由您的编排器配置）请检查您的可用工具中是否有：

find_symbol, find_referencing_symbols - 符号查找
rename_symbol, replace_symbol_body - 重构
insert_after_symbol, insert_before_symbol - 精确插入
onboarding, activate_project - 项目理解

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

何时使用此技能

当您需要符号级代码理解时，请使用 serena 技能：

查找类、函数或变量的定义位置
发现符号被使用的所有位置（调用点、导入、引用）
理解代码依赖关系和关联
通过函数调用追踪执行流程

分析对函数或类的更改影响
理解继承层次结构和类型关系
识别死代码（从未被引用的符号）
在代码库中映射 API 使用模式

重命名符号同时追踪所有使用位置
向特定类添加方法或字段
在特定函数调用后插入错误处理
修改已弃用函数的所有调用点

在以下情况下选择 serena 而非文件搜索（ripgrep/ast-grep）：

您需要理解符号语义（不仅仅是文本模式）
您希望跨文件和模块追踪引用
您需要基于代码结构的精确插入点
您正在处理复杂的、多文件的代码库

在以下情况下仍使用文件搜索：

搜索文本模式、注释或字符串
查找待办事项、安全问题或文档
您需要更快、更简单的模式匹配
不需要符号级精度

Serena 使用 LSP 服务器进行语义分析。大多数常见语言都开箱即用：

Python (pyright, jedi)
JavaScript/TypeScript (typescript-language-server)
Rust (rust-analyzer)
Go (gopls)
Java (jdtls)
C/C++ (clangd)
C#, Ruby, PHP, Kotlin, Swift, Scala 以及 15 种以上语言

LSP 服务器为您正在使用的语言提供符号信息。

1. 查找符号 (`find_symbol`)

定位符号在代码库中的定义位置。

注意： 以下所有示例均使用简写形式 serena <command>。完整命令是：

uvx --from git+https://github.com/oraios/serena serena <command>



# 查找类定义
execute_command("uvx --from git+https://github.com/oraios/serena serena find_symbol --name 'UserService' --type class")

# 查找函数定义
execute_command("uvx --from git+https://github.com/oraios/serena serena find_symbol --name 'authenticate' --type function")

# 查找变量定义
execute_command("uvx --from git+https://github.com/oraios/serena serena find_symbol --name 'API_KEY' --type variable")

在修改类之前定位其定义
查找函数的实现位置
理解常量的定义位置
在类型化语言中追踪类型定义

File: src/services/user_service.py
Line: 42
Symbol: UserService (class)
Context: class UserService(BaseService):

2. 查找引用 (`find_referencing_symbols`)

发现符号被使用、导入或引用的所有位置。

# 查找类的所有用法
execute_command("serena find_referencing_symbols --name 'UserService'")

# 查找函数的所有调用点
execute_command("serena find_referencing_symbols --name 'authenticate'")

# 查找变量的所有读/写操作
execute_command("serena find_referencing_symbols --name 'API_KEY'")

重构前的影响分析
查找函数的所有调用点
跨模块追踪 API 使用情况
识别未使用的符号（零引用）
理解数据流和依赖关系

Found 12 references to 'authenticate':

1. src/api/routes.py:34
   authenticate(user_credentials)

2. src/middleware/auth.py:18
   from services import authenticate

3. tests/test_auth.py:56
   mock_authenticate = Mock(spec=authenticate)
...

3. 精确代码插入 (`insert_after_symbol`)

以手术般的精度在特定符号位置插入代码。

# 向类添加方法
execute_command("""serena insert_after_symbol --name 'UserService' --type class --code '
    def get_user_by_email(self, email: str) -> Optional[User]:
        return self.db.query(User).filter_by(email=email).first()
'""")

# 在函数调用后插入错误处理
execute_command("""serena insert_after_symbol --name 'database_query' --code '
    if result is None:
        raise DatabaseError("Query returned no results")
'""")

# 向数据类添加字段
execute_command("""serena insert_after_symbol --name 'User' --type class --code '
    email_verified: bool = False
'""")

向现有类添加方法
插入验证或错误处理
向数据结构添加字段
注入日志记录或监控代码
实现缺失的功能

尊重缩进和代码格式
保持语法有效性
在作用域内正确定位代码
保留现有代码结构

模式 1：安全重构

当更改函数签名或行为时：

# 步骤 1：查找函数定义
serena find_symbol --name 'process_payment' --type function

# 步骤 2：查找所有调用点
serena find_referencing_symbols --name 'process_payment'

# 步骤 3：分析影响（审查输出）
# [审查所有使用位置以了解影响]

# 步骤 4：有信心地进行更改
# [根据发现更新函数和所有调用点]

模式 2：添加功能

当使用新方法扩展类时：

# 步骤 1：定位类
serena find_symbol --name 'PaymentProcessor' --type class

# 步骤 2：验证无冲突
serena find_symbol --name 'process_refund' --type function

# 步骤 3：插入新方法
serena insert_after_symbol --name 'PaymentProcessor' --type class --code '
    def process_refund(self, payment_id: str, amount: float) -> bool:
        # Implementation here
        pass
'

模式 3：理解依赖关系

当分析代码关系时：

# 步骤 1：查找类定义
serena find_symbol --name 'DatabaseManager' --type class

# 步骤 2：查找所有用法
serena find_referencing_symbols --name 'DatabaseManager'

# 步骤 3：对于每个用法，查找哪些符号使用该代码
# [重复引用追踪以构建依赖图]

模式 4：死代码检测

当识别未使用的代码时：

# 步骤 1：查找符号定义
serena find_symbol --name 'legacy_auth_handler'

# 步骤 2：检查引用
serena find_referencing_symbols --name 'legacy_auth_handler'

# 步骤 3：如果零引用（定义除外），标记为待删除
# [如果输出仅显示定义，则该符号未使用]

与文件搜索的集成

Serena 和文件搜索（ripgrep/ast-grep）是互补工具。结合使用它们：

何时组合使用工具

先使用 ripgrep 再使用 serena：

# 1. 使用 ripgrep 查找潜在匹配项（快速、广泛）
rg "authenticate" --type py

# 2. 使用 serena 缩小到特定符号（精确）
serena find_symbol --name 'authenticate' --type function
serena find_referencing_symbols --name 'authenticate'

先使用 serena 再使用 ripgrep：

# 1. 使用 serena 查找符号定义
serena find_symbol --name 'UserService'

# 2. 使用 ripgrep 搜索相关模式
rg "UserService\(" --type py  # 查找直接实例化
rg "class.*UserService" --type py  # 查找子类

任务	最佳工具	原因
查找字符串字面量	ripgrep	基于文本，快速
查找待办事项/注释	ripgrep	基于文本
查找符号定义	serena	符号感知
查找所有引用	serena	语义理解
查找代码模式	ast-grep	语法感知
在符号处插入	serena	精确定位
跨语言搜索	ripgrep	语言无关
理解作用域	serena	LSP 语义信息

1. 从符号发现开始

始终首先定位符号定义：

# 良好实践：先查找定义，再查找引用
serena find_symbol --name 'MyClass'
serena find_referencing_symbols --name 'MyClass'

# 避免：在未确认定义存在的情况下搜索引用

2. 使用特定的符号类型

尽可能使用 --type 缩小搜索范围：

# 良好实践：特定类型减少歧义
serena find_symbol --name 'User' --type class

# 精度较低：可能匹配 User 函数、User 变量等
serena find_symbol --name 'User'

在插入代码前始终查找符号：

# 良好实践：先验证目标存在
serena find_symbol --name 'PaymentService' --type class
# [审查输出以确认正确的类]
serena insert_after_symbol --name 'PaymentService' --code '...'

# 有风险：未经验证就插入
serena insert_after_symbol --name 'PaymentService' --code '...'

4. 审查引用计数

检查引用输出以进行影响分析：

# 查找引用并评估影响
serena find_referencing_symbols --name 'deprecated_function'
# 如果有 50+ 个引用，请规划仔细的迁移
# 如果 0 个引用，可以安全移除

5. 与 git diff 结合使用

插入后，验证更改：

serena insert_after_symbol --name 'MyClass' --code '...'
git diff  # 提交前审查实际更改

Serena 通过 LSP 集成支持 30 多种语言：

第 1 层（完全测试）：

Python, JavaScript, TypeScript, Rust, Go, Java, C/C++

第 2 层（社区测试）：

C#, Ruby, PHP, Kotlin, Swift, Scala

第 3 层（实验性）：

Haskell, Elixir, Clojure, Erlang, Julia, R 等

有关完整列表和设置说明，请参阅 Serena 语言支持文档。

何时不应使用 Serena

搜索文本/注释：请改用 ripgrep

# 错误工具：Serena 不搜索注释
serena find_symbol --name "TODO"

# 正确工具：使用 ripgrep 搜索文本
rg "TODO"

生成的代码：LSP 可能不会索引自动生成的文件
- 对于构建产物、生成的代码，请使用 ripgrep
非常大的代码库：符号索引可能很慢
- 对于初始的广泛搜索，请使用 ripgrep
- 对于精确的后续操作，请使用 serena
没有类型的动态语言：语义信息有限
- 没有类型提示的 Python 精度降低
- 没有 TypeScript 的 JavaScript 保证较少

歧义符号：多个同名符号可能需要手动消歧义
宏生成的代码：C/C++ 宏可能会混淆 LSP
循环依赖：可能影响引用追踪的准确性
不完整的项目：缺少依赖项会降低 LSP 的有效性

Serena 专为令牌高效的代码导航而设计：

# 传统方法（低效）
execute_command("cat entire_file.py")  # 1000+ 令牌
# [在输出中手动搜索符号]

# Serena 方法（高效）
serena find_symbol --name 'MyClass'  # 50 令牌
# [立即获得精确位置]

符号查找：近乎即时（LSP 已索引）
引用查找：快速（索引 O(log n)）
代码插入：即时（直接文件修改）

与替代方案的比较：

Ripgrep：文本搜索更快（无语义理解）
AST-grep：速度相当（语法 vs 语义）
Serena：初始启动较慢（LSP 索引），精确查询更快

如果 find_symbol 未返回结果：

验证符号是否存在：使用 ripgrep 确认
```
rg "class MyClass" --type py
```
检查语言服务器：确保已为语言配置 LSP
```
serena status  # 检查 LSP 服务器状态
```

尝试大小写变体：符号名称区分大小写

serena find_symbol --name 'myclass'  # 尝试不同的大小写

重建索引：强制 LSP 重新索引
```
serena reindex  # 重建符号索引
```

如果 find_referencing_symbols 返回数百个结果：

先使用文件搜索：使用 ripgrep 缩小范围

rg "MyClass" src/services/  # 限制到特定目录
serena find_referencing_symbols --name 'MyClass' --path src/services/

按引用类型过滤：专注于特定的使用模式

# 仅查找导入
rg "from .* import.*MyClass" --type py

优先处理最近的更改：先检查 git 历史记录
```
git log --all -p -S 'MyClass' --since="1 week ago"
```

如果 insert_after_symbol 失败：

验证符号是否存在：先找到它
检查语法：确保插入的代码有效
审查缩进：匹配周围代码风格
增量测试：先插入小的更改

2026 年 1 月 22 日

🇺🇸English

Serena: Symbol-Level Code Understanding

Navigate and manipulate code at the symbol level using IDE-like semantic analysis powered by Language Server Protocol (LSP).

How You Can Access Serena

You may have Serena available in one or both of these ways:

Option 1: Direct MCP Tools (if configured by your orchestrator) Check your available tools for:

find_symbol, find_referencing_symbols - Symbol lookup
rename_symbol, replace_symbol_body - Refactoring
insert_after_symbol, insert_before_symbol - Precise insertions
onboarding, activate_project - Project understanding
write_memory, read_memory - Save context
And 25+ more LSP-powered tools

If you see these tools, use them directly - they provide full Serena capabilities!

Option 2: CLI Commands (always available via execute_command) You can run serena commands using:

execute_command("uvx --from git+https://github.com/oraios/serena serena <command>")

This skill focuses on CLI usage patterns. If you have direct MCP tools, prefer those for better integration.

Purpose

The serena skill provides access to Serena, a coding agent toolkit that transforms text-based LLMs into symbol-aware code agents. Unlike traditional text search (ripgrep) or structural search (ast-grep), Serena understands code semantics through LSP integration.

Key capabilities:

Symbol Discovery : Find classes, functions, variables, and types by name across 30+ languages
Reference Tracking : Discover all locations where a symbol is referenced or used
Precise Editing : Insert code at specific symbol locations with surgical precision

Serena operates at the symbol level rather than the text or syntax level, providing true IDE-like understanding of code structure, scope, and relationships.

When to Use This Skill

Use the serena skill when you need symbol-level code understanding:

Code Navigation:

Finding where a class, function, or variable is defined
Discovering all places where a symbol is used (call sites, imports, references)
Understanding code dependencies and relationships
Tracing execution flow through function calls

Code Understanding:

Analyzing impact of changes to a function or class
Understanding inheritance hierarchies and type relationships
Identifying dead code (symbols never referenced)
Mapping API usage patterns across a codebase

Code Refactoring:

Renaming symbols while tracking all usage locations
Adding methods or fields to specific classes
Inserting error handling after specific function calls
Modifying all call sites of a deprecated function

Choose serena over file-search (ripgrep/ast-grep) when:

You need to understand symbol semantics (not just text patterns)
You want to track references across files and modules
You need precise insertion points based on code structure
You're working with complex, multi-file codebases

Still use file-search when:

Searching for text patterns, comments, or strings
Finding todos, security issues, or documentation
You need faster, simpler pattern matching
Symbol-level precision isn't required

Language Support

Serena uses LSP servers for semantic analysis. Most common languages are supported out-of-the-box:

Python (pyright, jedi)
JavaScript/TypeScript (typescript-language-server)
Rust (rust-analyzer)
Go (gopls)
Java (jdtls)
C/C++ (clangd)
C#, Ruby, PHP, Kotlin, Swift, Scala, and 15+ more

The LSP servers provide symbol information for the language you're working with.

Core Operations

1. Finding Symbols (`find_symbol`)

Locate where a symbol is defined in your codebase.

Note: All examples below use the short form serena <command>. The full command is:

uvx --from git+https://github.com/oraios/serena serena <command>



# Find a class definition
execute_command("uvx --from git+https://github.com/oraios/serena serena find_symbol --name 'UserService' --type class")

# Find a function definition
execute_command("uvx --from git+https://github.com/oraios/serena serena find_symbol --name 'authenticate' --type function")

# Find a variable definition
execute_command("uvx --from git+https://github.com/oraios/serena serena find_symbol --name 'API_KEY' --type variable")

Use cases:

Locating the definition of a class before modifying it
Finding where a function is implemented
Understanding where constants are defined
Tracing type definitions in typed languages

Output format:

File: src/services/user_service.py
Line: 42
Symbol: UserService (class)
Context: class UserService(BaseService):

2. Finding References (`find_referencing_symbols`)

Discover all locations where a symbol is used, imported, or referenced.

# Find all usages of a class
execute_command("serena find_referencing_symbols --name 'UserService'")

# Find all call sites of a function
execute_command("serena find_referencing_symbols --name 'authenticate'")

# Find all reads/writes of a variable
execute_command("serena find_referencing_symbols --name 'API_KEY'")

Use cases:

Impact analysis before refactoring
Finding all call sites of a function
Tracking API usage across modules
Identifying unused symbols (zero references)
Understanding data flow and dependencies

Output format:

Found 12 references to 'authenticate':

1. src/api/routes.py:34
   authenticate(user_credentials)

2. src/middleware/auth.py:18
   from services import authenticate

3. tests/test_auth.py:56
   mock_authenticate = Mock(spec=authenticate)
...

3. Precise Code Insertion (`insert_after_symbol`)

Insert code at specific symbol locations with surgical precision.

# Add a method to a class
execute_command("""serena insert_after_symbol --name 'UserService' --type class --code '
    def get_user_by_email(self, email: str) -> Optional[User]:
        return self.db.query(User).filter_by(email=email).first()
'""")

# Insert error handling after a function call
execute_command("""serena insert_after_symbol --name 'database_query' --code '
    if result is None:
        raise DatabaseError("Query returned no results")
'""")

# Add a field to a dataclass
execute_command("""serena insert_after_symbol --name 'User' --type class --code '
    email_verified: bool = False
'""")

Use cases:

Adding methods to existing classes
Inserting validation or error handling
Adding fields to data structures
Injecting logging or monitoring code
Implementing missing functionality

Safety features:

Respects indentation and code formatting
Maintains syntactic validity
Positions code correctly within scope
Preserves existing code structure

Workflow Patterns

Pattern 1: Safe Refactoring

When changing a function signature or behavior:

# Step 1: Find the function definition
serena find_symbol --name 'process_payment' --type function

# Step 2: Find all call sites
serena find_referencing_symbols --name 'process_payment'

# Step 3: Analyze impact (review output)
# [Review all usage locations to understand impact]

# Step 4: Make changes with confidence
# [Update function and all call sites based on findings]

Pattern 2: Adding Functionality

When extending a class with new methods:

# Step 1: Locate the class
serena find_symbol --name 'PaymentProcessor' --type class

# Step 2: Verify no conflicts
serena find_symbol --name 'process_refund' --type function

# Step 3: Insert new method
serena insert_after_symbol --name 'PaymentProcessor' --type class --code '
    def process_refund(self, payment_id: str, amount: float) -> bool:
        # Implementation here
        pass
'

Pattern 3: Understanding Dependencies

When analyzing code relationships:

# Step 1: Find class definition
serena find_symbol --name 'DatabaseManager' --type class

# Step 2: Find all usages
serena find_referencing_symbols --name 'DatabaseManager'

# Step 3: For each usage, find what symbols use that code
# [Repeat reference tracking to build dependency graph]

Pattern 4: Dead Code Detection

When identifying unused code:

# Step 1: Find symbol definition
serena find_symbol --name 'legacy_auth_handler'

# Step 2: Check references
serena find_referencing_symbols --name 'legacy_auth_handler'

# Step 3: If zero references (except definition), mark for removal
# [If output shows only the definition, symbol is unused]

Integration with file-search

Serena and file-search (ripgrep/ast-grep) are complementary tools. Use them together:

When to Combine Tools

Use ripgrep THEN serena:

# 1. Find potential matches with ripgrep (fast, broad)
rg "authenticate" --type py

# 2. Narrow to specific symbol with serena (precise)
serena find_symbol --name 'authenticate' --type function
serena find_referencing_symbols --name 'authenticate'

Use serena THEN ripgrep:

# 1. Find symbol definition with serena
serena find_symbol --name 'UserService'

# 2. Search for related patterns with ripgrep
rg "UserService\(" --type py  # Find direct instantiations
rg "class.*UserService" --type py  # Find subclasses

Complementary Strengths

Task	Best Tool	Why
Find string literals	ripgrep	Text-based, fast
Find TODOs/comments	ripgrep	Text-based
Find symbol definition	serena	Symbol-aware
Find all references	serena	Semantic understanding
Find code patterns	ast-grep	Syntax-aware
Insert at symbol	serena	Precise positioning
Search across languages	ripgrep	Language-agnostic
Understand scope	serena	LSP semantic info

Best Practices

1. Start with Symbol Discovery

Always locate the symbol definition first:

# GOOD: Find definition, then references
serena find_symbol --name 'MyClass'
serena find_referencing_symbols --name 'MyClass'

# AVOID: Searching for references without confirming definition exists

2. Use Specific Symbol Types

Narrow searches with --type when possible:

# GOOD: Specific type reduces ambiguity
serena find_symbol --name 'User' --type class

# LESS PRECISE: May match User function, User variable, etc.
serena find_symbol --name 'User'

3. Verify Before Inserting

Always find the symbol before inserting code:

# GOOD: Verify target exists first
serena find_symbol --name 'PaymentService' --type class
# [Review output to confirm correct class]
serena insert_after_symbol --name 'PaymentService' --code '...'

# RISKY: Inserting without verification
serena insert_after_symbol --name 'PaymentService' --code '...'

4. Review Reference Counts

Check reference output for impact analysis:

# Find references and assess impact
serena find_referencing_symbols --name 'deprecated_function'
# If 50+ references, plan careful migration
# If 0 references, safe to remove

5. Combine with git diff

After insertions, verify changes:

serena insert_after_symbol --name 'MyClass' --code '...'
git diff  # Review actual changes before committing

Supported Languages

Serena supports 30+ languages through LSP integration:

Tier 1 (Fully tested):

Python, JavaScript, TypeScript, Rust, Go, Java, C/C++

Tier 2 (Community tested):

C#, Ruby, PHP, Kotlin, Swift, Scala

Tier 3 (Experimental):

Haskell, Elixir, Clojure, Erlang, Julia, R, and more

For the complete list and setup instructions, see Serena language support docs.

Limitations

When NOT to Use Serena

Searching text/comments : Use ripgrep instead

# WRONG TOOL: Serena doesn't search comments
serena find_symbol --name "TODO"

# RIGHT TOOL: Use ripgrep for text
rg "TODO"

Generated code : LSP may not index auto-generated files
- Use ripgrep for build artifacts, generated code
Very large codebases : Symbol indexing can be slow
- Use ripgrep for initial broad searches
- Use serena for precise follow-up
Dynamic languages without types : Limited semantic info
- Python without type hints has reduced precision
- JavaScript without TypeScript has fewer guarantees

Known Edge Cases

Ambiguous symbols : Multiple symbols with same name may require manual disambiguation
Macro-generated code : C/C++ macros may confuse LSP
Circular dependencies : May affect reference tracking accuracy
Incomplete projects : Missing dependencies can reduce LSP effectiveness

Performance Considerations

Token Efficiency

Serena is designed for token-efficient code navigation :

# Traditional approach (inefficient)
execute_command("cat entire_file.py")  # 1000+ tokens
# [Search for symbol manually in output]

# Serena approach (efficient)
serena find_symbol --name 'MyClass'  # 50 tokens
# [Get precise location immediately]

Speed Characteristics

Symbol lookup : Near-instant (LSP indexed)
Reference finding : Fast (O(log n) with indexing)
Code insertion : Instant (direct file modification)

Comparison with alternatives:

Ripgrep: Faster for text search (no semantic understanding)
AST-grep: Comparable speed (syntax vs semantic)
Serena: Slower initial startup (LSP indexing), faster precise queries

Troubleshooting

Symbol Not Found

If find_symbol returns no results:

Verify symbol exists : Use ripgrep to confirm
```
rg "class MyClass" --type py
```
Check language server : Ensure LSP is configured for the language
```
serena status  # Check LSP server status
```

Try case variations : Symbol names are case-sensitive

serena find_symbol --name 'myclass'  # Try different cases

Rebuild index : Force LSP to re-index
```
serena reindex  # Rebuild symbol index
```

Too Many References

If find_referencing_symbols returns hundreds of results:

Use file-search first : Narrow scope with ripgrep

rg "MyClass" src/services/  # Limit to specific directory
serena find_referencing_symbols --name 'MyClass' --path src/services/

Filter by reference type : Focus on specific usage patterns

# Look for imports only
rg "from .* import.*MyClass" --type py

Prioritize recent changes : Check git history first

git log --all -p -S 'MyClass' --since="1 week ago"

Insertion Failures

If insert_after_symbol fails:

Verify symbol exists : Find it first
Check syntax : Ensure inserted code is valid
Review indentation : Match surrounding code style
Test incrementally : Insert small changes first

Resources

Weekly Installs

Repository

massgen/massgen

GitHub Stars

891

First Seen

Jan 22, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

Installed on

codex70

opencode70

claude-code66

gemini-cli65

github-copilot61

cursor57

agent-browser 浏览器自动化工具 - Vercel Labs 命令行网页操作与测试

163,300 周安装

Serena：基于LSP的符号级代码理解与重构工具，支持30+编程语言

🇨🇳中文介绍

Serena：符号级代码理解

如何访问 Serena

相关 Skills

目的

何时使用此技能

语言支持

核心操作

1. 查找符号 (find_symbol)

2. 查找引用 (find_referencing_symbols)

3. 精确代码插入 (insert_after_symbol)

工作流模式

模式 1：安全重构

模式 2：添加功能

模式 3：理解依赖关系

模式 4：死代码检测

与文件搜索的集成

何时组合使用工具

互补优势

最佳实践

1. 从符号发现开始

2. 使用特定的符号类型

3. 插入前验证

4. 审查引用计数

5. 与 git diff 结合使用

支持的语言

限制

何时不应使用 Serena

已知边缘情况

性能考虑

令牌效率

速度特性

故障排除

符号未找到

引用过多

插入失败

资源

🇺🇸English

Serena: Symbol-Level Code Understanding

How You Can Access Serena

Purpose

When to Use This Skill

Language Support

Core Operations

1. Finding Symbols (find_symbol)

2. Finding References (find_referencing_symbols)

3. Precise Code Insertion (insert_after_symbol)

Workflow Patterns

Pattern 1: Safe Refactoring

Pattern 2: Adding Functionality

Pattern 3: Understanding Dependencies

Pattern 4: Dead Code Detection

Integration with file-search

When to Combine Tools

Complementary Strengths

Best Practices

1. Start with Symbol Discovery

2. Use Specific Symbol Types

3. Verify Before Inserting

4. Review Reference Counts

5. Combine with git diff

Supported Languages

Limitations

When NOT to Use Serena

Known Edge Cases

Performance Considerations

Token Efficiency

Speed Characteristics

Troubleshooting

Symbol Not Found

Too Many References

Insertion Failures

Resources

最新 Skills

1. 查找符号 (`find_symbol`)

2. 查找引用 (`find_referencing_symbols`)

3. 精确代码插入 (`insert_after_symbol`)

1. Finding Symbols (`find_symbol`)

2. Finding References (`find_referencing_symbols`)

3. Precise Code Insertion (`insert_after_symbol`)