菜单
[Code Intelligence] Use when you need to query code relationships and connections using the structural knowledge graph.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/duc01226/EasyPlatform --skill graph-query命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
[Architecture] Use when designing solution architecture across backend, frontend, deployment, monitoring, testing, and code quality.
[Utilities] Use when you need to answer technical and architectural questions.
[Content] Use when you need to brainstorm as a PO/BA — structured ideation for problem-solving, new product creation, or feature enhancement.
基于 SOC 职业分类
| name | graph-query |
| description | [Code Intelligence] Use when you need to query code relationships and connections using the structural knowledge graph. |
| version | 1.0.0 |
Goal: [Code Intelligence] Query code relationships and connections using the structural knowledge graph. Show related files, callers, callees, imports, tests, inheritance, and file structure. Requires graph to be built first via /graph-build. Triggers on "who calls", "what imports", "related files", "connections of", "depends on", "tests for", "inherits from", "file structure", "graph query".
Workflow:
Key Rules:
file:line) with confidence >80% to act..code-graph/graph.db. If missing, tell user to run /graph-build first.Map user's question to the appropriate query pattern(s):
| User asks... |
|---|
| Pattern(s) / Command |
|---|
| "who/what calls X", "callers of X" | callers_of |
| "what does X call", "callees of X" | callees_of |
| "what does X import", "X depends on", "deps of X" | imports_of |
| "who/what imports X", "importers of X", "who references X" | importers_of |
| "who uses X", "what uses X", "reverse deps of X" | importers_of |
| "what's inside X", "structure of X", "contents" | file_summary (files) / children_of |
| "what tests cover X", "tests for X" | tests_for |
| "who inherits/extends X", "subclasses of X" | inheritors_of |
| "show all connections/related files of X", "graph connections" | connections command (see below) |
For composite queries ("show all connections", "related files", "full picture"), use the connections command instead of running multiple queries manually.
ls .code-graph/graph.db 2>/dev/null && echo "OK" || echo "MISSING"
If MISSING: stop and tell user to run /graph-build.
Extract the target from user's question (file path, function name, or class name).
{source-root}/utils)validateInput) or qualified name (e.g., {source-root}/utils::validateInput)Execute via Bash with --json flag:
python .claude/scripts/code_graph query <pattern> <target> --json
For composite "show all connections" queries, use the connections command instead:
python .claude/scripts/code_graph connections <target> --json
This returns file_summary, imports_of, importers_of, callers_of, and tests_for in one call (capped at 20 results per section).
Tip: Add --node-mode file to query, connections, or trace for a file-level overview with 10-30x less noise. Options: file, function, class, all (default).
status: "ok" -- Parse results[] and edges[], format report (Step 5)status: "ambiguous" -- Multiple matches found. Show candidates[] list and ask user to pick one using AskUserQuestionstatus: "not_found" -- No match. Suggest: check spelling, use relative file path, try a different name. Optionally run file_summary on the parent file to show available names.status: "error" -- Show error message. Common: graph.db missing, Python version too old.Present results grouped by relationship type. For each result show:
file:line_start-line_end)Single query output format:
## {Pattern Description} for `{target}`
Found {N} result(s).
| Name | Kind | File | Lines |
|------|------|------|-------|
| ... | function | {source-root}/file | 10-25 |
Composite query output format:
## Connections of `{target}`
### File Summary
{N} nodes: {list functions/classes}
### Imports (outgoing)
{What this file/module imports}
### Importers (incoming)
{Who imports this file/module}
### Callers
{Functions that call functions in this file}
### Test Coverage
{Tests covering functions in this file}
When the user asks about a FLOW or BEHAVIOR (not a specific file), follow this protocol:
Use Grep/Glob/Search to find key classes/functions related to the user's query.
CreateX, XCommand, XHandler) and trace both directions.Run connections or batch-query on the grep-discovered files to find ALL related files. For bugs, group results by final reader, storage/projection, writer, consumer/job, and producer/origin.
Run the trace command to follow the complete chain through all edge types:
python .claude/scripts/code_graph trace <entry-file> --direction both --depth 3 --json
This traces upstream (who calls this?) AND downstream (what does this trigger?) through: CALLS → TRIGGERS_EVENT → PRODUCES_EVENT → MESSAGE_BUS → API_ENDPOINT
For bug/failure symptoms, run an upstream-first pass from the final output before expanding the suspected producer:
python .claude/scripts/code_graph trace <final-reader-or-output-file> --direction upstream --depth 5 --json
python .claude/scripts/code_graph batch-query <final-reader> <writer> <producer> --json
For any graph edge that seems surprising, verify with grep that the connection is real.
| Pattern | Description | Edge Kind |
|---|---|---|
callers_of | Functions that call the target function | CALLS |
callees_of | Functions called by the target function | CALLS |
imports_of | What the target file/module imports | IMPORTS_FROM |
importers_of | Files that import the target file/module | IMPORTS_FROM |
children_of | Nodes contained in a file or class | CONTAINS |
tests_for | Tests covering the target function/class | TESTED_BY + naming |
inheritors_of | Classes inheriting from the target class | INHERITS / IMPLEMENTS |
file_summary | All nodes (functions, classes) in a file | (direct lookup) |
trace | Full system flow from a target node | All edge types (BFS) |
Aliases (natural language mappings):
| Alias | Resolves to |
|---|---|
references_of | importers_of |
uses_of | callers_of |
who_calls | callers_of |
who_imports | importers_of |
depends_on | imports_of |
subclasses_of | inheritors_of |
extends | inheritors_of |
When you don't know the exact name, search first to find candidates:
python .claude/scripts/code_graph search <keyword> --json
python .claude/scripts/code_graph search <keyword> --kind Function --json
python .claude/scripts/code_graph search <keyword> --kind Class --limit 5 --json
Use search to disambiguate when a query returns status: "ambiguous" — narrow results by --kind (Function, Class, File, Type, Test) then use the full qualified_name.
Discover how two nodes are connected through the dependency graph:
python .claude/scripts/code_graph find-path <source> <target> --json
Returns the shortest path as a list of nodes. Useful for tracing how a command reaches an event handler, or how a frontend component connects to a backend entity.
Tip: If ambiguous, search for exact qualified names first, then use those in find-path.
Control result size for large codebases:
# Limit results
python .claude/scripts/code_graph query callers_of <target> --limit 5 --json
# Filter by file path regex
python .claude/scripts/code_graph query importers_of <target> --filter "ServiceName" --json
# Limit connections per section
python .claude/scripts/code_graph connections <target> --limit 10 --json
Implicit connection edge types (created by connect-implicit):
| Edge Kind | Meaning |
|---|---|
TRIGGERS_EVENT | Entity CRUD triggers event handler |
PRODUCES_EVENT | Event handler triggers bus message producer |
MESSAGE_BUS | Message bus producer to consumer |
TRIGGERS_COMMAND_EVENT | Command triggers command event handler |
When reviewing multiple files, use batch mode for deduplicated results:
python .claude/scripts/code_graph batch-query file1 file2 file3 --json
Returns: deduplicated nodes + edges (internal + 1-hop external) across all queried files. Single DB connection, no duplicate data.
Trace all connections from a target node through multiple edge types using BFS:
python .claude/scripts/code_graph trace <target> --json
python .claude/scripts/code_graph trace <target> --direction both --json
python .claude/scripts/code_graph trace <target> --direction upstream --depth 2 --json
python .claude/scripts/code_graph trace <target> --edge-kinds CALLS,MESSAGE_BUS --json
python .claude/scripts/code_graph trace <target> --direction both --node-mode file --json # file-level overview
Direction options:
downstream (default): Follow outgoing edges. "What happens after X?"upstream: Follow incoming edges. "What calls/triggers X?"both: Both directions. "Full flow through X" — use when entry point is a middle file (controller, command handler)Returns a multi-level tree of connected nodes grouped by BFS depth, with edge types at each level.
When a grep/glob surfaces an important entry-point file — an entity, command, query, event/command handler, controller, bus message/consumer, component, store, or api-service — immediately run a graph trace on it before concluding. Grep finds files; the trace reveals callers, consumers, bus messages, event chains, and tests that grep CANNOT find:
python .claude/scripts/code_graph trace <key-entry-file> --direction both --json
Pattern: grep finds files → graph trace reveals full system flow → grep verifies specific details.
/graph-build for that. This skill only queries./graph-blast-radius for git-diff-based impact./graph-export for full graph dump./graph-export --format=mermaid for Mermaid visualization.--json flag -- ensures structured parseable output./graph-build -- Build or update the graph (prerequisite)/graph-blast-radius -- Change-driven impact analysis from git diff/graph-export -- Export full graph to JSON (--format=json) or a single file as a Mermaid diagram (--format=mermaid)Query code relationships using the structural knowledge graph. Maps natural language questions to graph CLI queries and formats structured reports.
End-to-Start Debugger Trace — For non-trivial bugs, failed verification, regression fixes, behavior-changing code, or unclear code flow, start from the observed final state and walk backward before proposing a fix.
- Frame 0: observed end state — Name the exact user-visible output, failing assertion, log line, persisted value, API response, rendered UI, or aggregate bucket. Record the reader/query/renderer that produced it with
file:lineevidence.- Walk backward one hop at a time — Trace final reader -> projection/cache/storage -> writer -> consumer/handler/job -> producer/caller -> original trigger. At every hop record: input, transformation, output, owner, and evidence.
- Enumerate all feeder paths — Find every upstream producer/caller/event/job that can write into the final path, including retry, async, cache, background, and alternate UI/API paths. Mark each path verified, ruled out, or still unknown.
- Build the hypothesis matrix — For each plausible cause, list evidence for, evidence against, how to reproduce/verify, blast radius, and status (
primary,contributing,ruled out,latent). Do not fix until competing causes are explicitly resolved or bounded.- Choose the owning fix layer — Identify the invariant owner and the lowest shared point that protects all downstream consumers. A fix at the symptom site is rejected unless the symptom site owns the invariant.
- Prove convergence forward — After choosing the fix, walk start -> end again and show how the corrected state reaches the observed final output. Map each root cause to a fix part and each fix part to a test/proof.
BLOCKED until: final state named · backward trace written · all feeder paths enumerated · hypothesis matrix completed · owning fix layer justified · forward convergence proof mapped to tests.
NEVER: Start at the first suspicious code path. Collapse multiple producers into one "flow". Treat duplicate symptoms as duplicate records without proving the read model. Skip ruled-out hypotheses.
AI Mistake Prevention — Failure modes to avoid on every task:
Re-read files after context changes. Context compaction, resume, or long-running work can make memory stale; verify current files before acting. Verify generated content against source evidence. AI hallucinates APIs, names, claims, and document facts. Check the relevant source before documenting or referencing. Check downstream references before deleting or renaming. Removing an artifact can stale docs, generated mirrors, configs, and callers; map references first. Trace the full impact chain after edits. Changing a definition can miss derived outputs and consumers. Follow the affected chain before declaring done. Verify ALL affected outputs, not just the first. One green check is not all green checks; validate every output surface the change can affect. Assume existing values are intentional — ask WHY before changing. Before changing a constant, limit, flag, wording, or pattern, read nearby context and history. Surface ambiguity before acting — don't pick silently. Multiple valid interpretations require an explicit question or stated assumption with risk. Keep shared guidance role-relevant. Universal guidance must help every receiving skill or agent; code-specific obligations belong only in code-specific protocols.
Critical Thinking Mindset — Apply critical thinking, sequential thinking. Every claim needs traced proof, confidence >80% to act. Anti-hallucination: Never present guess as fact — cite sources for every claim, admit uncertainty freely, self-check output for errors, cross-reference independently, stay skeptical of own confidence — certainty without evidence root of all hallucination.
MUST ATTENTION apply critical + sequential thinking — every claim needs appropriate traced evidence (file:line for repo/code claims; source URL or artifact section for research, product, content, and docs claims); confidence >80% to act, <60% DO NOT recommend. Anti-hallucination: never present guess as fact, admit uncertainty freely, cross-reference independently, stay skeptical of own confidence.
MUST ATTENTION apply AI mistake prevention — verify generated content against evidence, trace downstream references before deleting or renaming, verify all affected outputs, re-read files after context loss, and surface ambiguity before acting.
IMPORTANT MUST ATTENTION debugger trace gate: for non-trivial bug/fix/investigation/review work, start at the observed final output and trace backward through reader -> storage/projection -> writer -> consumer/job -> producer/trigger. Enumerate all feeder paths and hypotheses before fixing. BLOCKED until trace, hypothesis matrix, owning fix layer, and forward convergence proof exist.
Protocols in force (concise digest of the SYNC/shared blocks this skill carries):
End-To-Start Debugger Trace: start at observed final output, trace backward, hypothesis matrix before fixing.
AI Mistake Prevention: verify generated content against evidence, trace downstream references, verify all affected outputs, re-read after context loss, surface ambiguity.
Critical Thinking: every claim needs traced file:line proof, confidence >80% to act.
MANDATORY IMPORTANT MUST ATTENTION break work into small todo tasks using TaskCreate BEFORE starting
MANDATORY IMPORTANT MUST ATTENTION search codebase for 3+ similar patterns before creating new code
MANDATORY IMPORTANT MUST ATTENTION cite file:line evidence for every claim (confidence >80% to act)
MANDATORY IMPORTANT MUST ATTENTION add a final review todo task to verify work quality
[TASK-PLANNING] Before acting, analyze task scope and systematically break it into small todo tasks and sub-tasks using TaskCreate.