grepai-trace-graph：代码依赖关系可视化与调用图生成工具

grepai-trace-graph by yoanbernabeu/grepai-skills

304 周安装量

15 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/yoanbernabeu/grepai-skills --skill grepai-trace-graph

开发自动化代码规范

🇨🇳中文介绍

GrepAI 追踪图

此技能涵盖使用 grepai trace graph 构建完整的调用图，以递归方式显示所有依赖关系。

何时使用此技能

映射完整的函数依赖关系
理解复杂的代码流程
重大重构的影响分析
可视化应用程序架构

什么是追踪图？

grepai trace graph 构建一个递归的依赖树：

main
├── initialize
│   ├── loadConfig
│   │   └── parseYAML
│   └── connectDB
│       ├── createPool
│       └── ping
├── startServer
│   ├── registerRoutes
│   │   ├── authMiddleware
│   │   └── loggingMiddleware
│   └── listen
└── gracefulShutdown
    └── closeDB

基本用法

grepai trace graph "FunctionName"

示例

grepai trace graph "main"

输出：

🔍 Call Graph for "main"

main
├── initialize
│   ├── loadConfig
│   └── connectDB
├── startServer
│   ├── registerRoutes
│   └── listen
└── gracefulShutdown
    └── closeDB

Nodes: 9
Max depth: 3

广告位招租

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

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

联系我们

TOON 输出 (v0.26.0+)

TOON 格式比 JSON 少用约 50% 的令牌：

grepai trace graph "main" --depth 2 --toon

注意： --json 和 --toon 是互斥的。

# 快速模式（基于正则表达式）
grepai trace graph "main" --mode fast

# 精确模式（tree-sitter AST）
grepai trace graph "main" --mode precise

理解应用程序流程

# 映射整个应用程序启动过程
grepai trace graph "main" --depth 4

# 哪些功能依赖这个工具函数？
grepai trace graph "validateInput" --depth 3

# 更改数据库层的完整影响
grepai trace graph "executeQuery" --depth 2

# 这个函数是否过于复杂？
grepai trace graph "processOrder" --depth 5
# 节点多 = 复杂度高

# 生成架构图数据
grepai trace graph "main" --depth 3 --json > architecture.json

# 如果更改这个，什么会出问题？
grepai trace graph "legacyAuth" --depth 3

GrepAI 检测并标记循环依赖：

main
├── processA
│   └── processB
│       └── processA [CYCLE]

{
  "name": "processA",
  "cycle": true
}

对于非常大的代码库，图可能会过于庞大：

# 从浅层开始
grepai trace graph "main" --depth 2

专注于特定区域

# 不追踪 main，而是追踪特定的子系统
grepai trace graph "authMiddleware" --depth 3

在后处理中过滤

# 获取 JSON 并进行过滤
grepai trace graph "main" --depth 3 --json | jq '...'

导出为 DOT 格式 (Graphviz)

# 将 JSON 转换为 DOT
grepai trace graph "main" --depth 3 --json | python3 << 'EOF'
import json
import sys

data = json.load(sys.stdin)

print("digraph G {")
print("  rankdir=TB;")

def traverse(node, parent=None):
    name = node.get('name') or node.get('n')
    if parent:
        print(f'  "{parent}" -> "{name}";')
    children = node.get('children') or node.get('c') or []
    for child in children:
        traverse(child, name)

traverse(data.get('root') or data.get('r'))
print("}")
EOF

dot -Tpng graph.dot -o graph.png

grepai trace graph "main" --depth 2 --json | python3 << 'EOF'
import json
import sys

data = json.load(sys.stdin)

print("```mermaid")
print("graph TD")

def traverse(node, parent=None):
    name = node.get('name') or node.get('n')
    if parent:
        print(f"  {parent} --> {name}")
    children = node.get('children') or node.get('c') or []
    for child in children:
        traverse(child, name)

traverse(data.get('root') or data.get('r'))
print("```")
EOF

随时间跟踪复杂度：

# 获取节点数
grepai trace graph "main" --depth 3 --json | jq '.stats.nodes'

# 比较重构前后的情况
echo "Before: $(grepai trace graph 'main' --depth 3 --json | jq '.stats.nodes') nodes"
# ... 重构 ...
echo "After: $(grepai trace graph 'main' --depth 3 --json | jq '.stats.nodes') nodes"

❌ 问题： 图太大 / 超时 ✅ 解决方案：

减小深度：--depth 2
追踪特定函数而不是 main
使用 --mode fast

❌ 问题： 检测到许多循环依赖 ✅ 解决方案： 这表明代码中存在循环依赖。考虑进行重构。

❌ 问题： 缺少分支 ✅ 解决方案：

尝试 --mode precise
检查文件是否已索引
确认语言已启用

从浅层开始： 从 --depth 2 开始，根据需要增加
聚焦分析： 追踪特定函数，不总是 main
导出用于文档： 使用 JSON 生成图表
随时间跟踪： 将节点数作为复杂度指标进行监控
调查循环依赖： 循环依赖是代码异味

🔍 Call Graph for "main"

Depth: 3
Mode: fast

main
├── initialize
│   ├── loadConfig
│   │   └── parseYAML
│   └── connectDB
│       ├── createPool
│       └── ping
├── startServer
│   ├── registerRoutes
│   │   ├── authMiddleware
│   │   └── loggingMiddleware
│   └── listen
└── gracefulShutdown
    └── closeDB

Statistics:
- Total nodes: 12
- Maximum depth reached: 3
- Cycles detected: 0

Tip: Use --json for machine-readable output
     Use --depth N to control recursion depth

2026 年 1 月 28 日

🇺🇸English

GrepAI Trace Graph

This skill covers using grepai trace graph to build complete call graphs showing all dependencies recursively.

When to Use This Skill

Mapping complete function dependencies
Understanding complex code flows
Impact analysis for major refactoring
Visualizing application architecture

What is Trace Graph?

grepai trace graph builds a recursive dependency tree:

main
├── initialize
│   ├── loadConfig
│   │   └── parseYAML
│   └── connectDB
│       ├── createPool
│       └── ping
├── startServer
│   ├── registerRoutes
│   │   ├── authMiddleware
│   │   └── loggingMiddleware
│   └── listen
└── gracefulShutdown
    └── closeDB

Basic Usage

grepai trace graph "FunctionName"

Example

grepai trace graph "main"

Output:

🔍 Call Graph for "main"

main
├── initialize
│   ├── loadConfig
│   └── connectDB
├── startServer
│   ├── registerRoutes
│   └── listen
└── gracefulShutdown
    └── closeDB

Nodes: 9
Max depth: 3

Depth Control

Limit recursion depth with --depth:

# Default depth (2 levels)
grepai trace graph "main"

# Deeper analysis (3 levels)
grepai trace graph "main" --depth 3

# Shallow (1 level, same as callees)
grepai trace graph "main" --depth 1

# Very deep (5 levels)
grepai trace graph "main" --depth 5

Depth Examples

--depth 1 (same as callees):

main
├── initialize
├── startServer
└── gracefulShutdown

--depth 2 (default):

main
├── initialize
│   ├── loadConfig
│   └── connectDB
├── startServer
│   ├── registerRoutes
│   └── listen
└── gracefulShutdown
    └── closeDB

--depth 3 :

main
├── initialize
│   ├── loadConfig
│   │   └── parseYAML
│   └── connectDB
│       ├── createPool
│       └── ping
├── startServer
│   ├── registerRoutes
│   │   ├── authMiddleware
│   │   └── loggingMiddleware
│   └── listen
└── gracefulShutdown
    └── closeDB

JSON Output

grepai trace graph "main" --depth 2 --json

Output:

{
  "query": "main",
  "mode": "graph",
  "depth": 2,
  "root": {
    "name": "main",
    "file": "cmd/main.go",
    "line": 10,
    "children": [
      {
        "name": "initialize",
        "file": "cmd/main.go",
        "line": 15,
        "children": [
          {
            "name": "loadConfig",
            "file": "config/config.go",
            "line": 20,
            "children": []
          },
          {
            "name": "connectDB",
            "file": "db/db.go",
            "line": 30,
            "children": []
          }
        ]
      },
      {
        "name": "startServer",
        "file": "server/server.go",
        "line": 25,
        "children": [
          {
            "name": "registerRoutes",
            "file": "server/routes.go",
            "line": 10,
            "children": []
          }
        ]
      }
    ]
  },
  "stats": {
    "nodes": 6,
    "max_depth": 2
  }
}

Compact JSON

grepai trace graph "main" --depth 2 --json --compact

Output:

{
  "q": "main",
  "d": 2,
  "r": {
    "n": "main",
    "c": [
      {"n": "initialize", "c": [{"n": "loadConfig"}, {"n": "connectDB"}]},
      {"n": "startServer", "c": [{"n": "registerRoutes"}]}
    ]
  },
  "s": {"nodes": 6, "depth": 2}
}

TOON Output (v0.26.0+)

TOON format offers ~50% fewer tokens than JSON:

grepai trace graph "main" --depth 2 --toon

Note: --json and --toon are mutually exclusive.

Extraction Modes

# Fast mode (regex-based)
grepai trace graph "main" --mode fast

# Precise mode (tree-sitter AST)
grepai trace graph "main" --mode precise

Use Cases

Understanding Application Flow

# Map entire application startup
grepai trace graph "main" --depth 4

Impact Analysis

# What depends on this utility function?
grepai trace graph "validateInput" --depth 3

# Full impact of changing database layer
grepai trace graph "executeQuery" --depth 2

Code Review

# Is this function too complex?
grepai trace graph "processOrder" --depth 5
# Many nodes = high complexity

Documentation

# Generate architecture diagram data
grepai trace graph "main" --depth 3 --json > architecture.json

Refactoring Planning

# What would break if we change this?
grepai trace graph "legacyAuth" --depth 3

Handling Cycles

GrepAI detects and marks circular dependencies:

main
├── processA
│   └── processB
│       └── processA [CYCLE]

In JSON:

{
  "name": "processA",
  "cycle": true
}

Large Graphs

For very large codebases, graphs can be overwhelming:

Limit Depth

# Start shallow
grepai trace graph "main" --depth 2

Focus on Specific Areas

# Instead of main, trace specific subsystem
grepai trace graph "authMiddleware" --depth 3

Filter in Post-Processing

# Get JSON and filter
grepai trace graph "main" --depth 3 --json | jq '...'

Visualizing Graphs

Export to DOT Format (Graphviz)

# Convert JSON to DOT
grepai trace graph "main" --depth 3 --json | python3 << 'EOF'
import json
import sys

data = json.load(sys.stdin)

print("digraph G {")
print("  rankdir=TB;")

def traverse(node, parent=None):
    name = node.get('name') or node.get('n')
    if parent:
        print(f'  "{parent}" -> "{name}";')
    children = node.get('children') or node.get('c') or []
    for child in children:
        traverse(child, name)

traverse(data.get('root') or data.get('r'))
print("}")
EOF

Then render:

dot -Tpng graph.dot -o graph.png

Mermaid Diagram

grepai trace graph "main" --depth 2 --json | python3 << 'EOF'
import json
import sys

data = json.load(sys.stdin)

print("```mermaid")
print("graph TD")

def traverse(node, parent=None):
    name = node.get('name') or node.get('n')
    if parent:
        print(f"  {parent} --> {name}")
    children = node.get('children') or node.get('c') or []
    for child in children:
        traverse(child, name)

traverse(data.get('root') or data.get('r'))
print("```")
EOF

Comparing Graph Sizes

Track complexity over time:

# Get node count
grepai trace graph "main" --depth 3 --json | jq '.stats.nodes'

# Compare before/after refactoring
echo "Before: $(grepai trace graph 'main' --depth 3 --json | jq '.stats.nodes') nodes"
# ... refactoring ...
echo "After: $(grepai trace graph 'main' --depth 3 --json | jq '.stats.nodes') nodes"

Common Issues

❌ Problem: Graph too large / timeout ✅ Solutions:

Reduce depth: --depth 2
Trace specific function instead of main
Use --mode fast

❌ Problem: Many cycles detected ✅ Solution: This indicates circular dependencies in code. Consider refactoring.

❌ Problem: Missing branches ✅ Solutions:

Try --mode precise
Check if files are indexed
Verify language is enabled

Best Practices

Start shallow: Begin with --depth 2, increase as needed
Focus analysis: Trace specific functions, not always main
Export for docs: Use JSON for generating diagrams
Track over time: Monitor node count as complexity metric
Investigate cycles: Circular dependencies are code smells

Output Format

Trace graph result:

🔍 Call Graph for "main"

Depth: 3
Mode: fast

main
├── initialize
│   ├── loadConfig
│   │   └── parseYAML
│   └── connectDB
│       ├── createPool
│       └── ping
├── startServer
│   ├── registerRoutes
│   │   ├── authMiddleware
│   │   └── loggingMiddleware
│   └── listen
└── gracefulShutdown
    └── closeDB

Statistics:
- Total nodes: 12
- Maximum depth reached: 3
- Cycles detected: 0

Tip: Use --json for machine-readable output
     Use --depth N to control recursion depth

Weekly Installs

304

Repository

yoanbernabeu/gr…i-skills

GitHub Stars

First Seen

Jan 28, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode244

codex236

gemini-cli217

github-copilot214

kimi-cli201

amp199

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

138,300 周安装

grepai-trace-graph：代码依赖关系可视化与调用图生成工具

🇨🇳中文介绍

GrepAI 追踪图

何时使用此技能

什么是追踪图？

基本用法

示例

相关 Skills

深度控制

深度示例

JSON 输出

紧凑型 JSON

TOON 输出 (v0.26.0+)

提取模式

使用案例

理解应用程序流程

影响分析

代码审查

文档生成

重构规划

处理循环依赖

大型图

限制深度

专注于特定区域

在后处理中过滤

可视化图

导出为 DOT 格式 (Graphviz)

Mermaid 图

比较图的大小

常见问题

最佳实践

输出格式

🇺🇸English

GrepAI Trace Graph

When to Use This Skill

What is Trace Graph?

Basic Usage

Example

Depth Control

Depth Examples

JSON Output

Compact JSON

TOON Output (v0.26.0+)

Extraction Modes

Use Cases

Understanding Application Flow

Impact Analysis

Code Review

Documentation

Refactoring Planning

Handling Cycles

Large Graphs

Limit Depth

Focus on Specific Areas

Filter in Post-Processing

Visualizing Graphs

Export to DOT Format (Graphviz)

Mermaid Diagram

Comparing Graph Sizes

Common Issues

Best Practices

Output Format

最新 Skills