dsh-code-review-graph 0.0.0-stage → 0.1.0

package/skills/explore-codebase/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: explore-codebase
+description: Navigate and understand codebase structure using the knowledge graph
+---
+
+## Explore Codebase
+
+Use the code-review-graph MCP tools to find your way around the codebase.
+
+### Steps
+
+1. Call `get_architecture_overview_tool` for the community structure. Call `list_communities_tool`, then `get_community_tool`, only for the modules you need.
+2. Call `semantic_search_nodes_tool` to find a function or class by name or keyword.
+3. Call `query_graph_tool` with `callers_of`, `callees_of` or `imports_of` to trace relationships. `children_of` on a file lists its functions and classes.
+4. Call `list_flows_tool`, then `get_flow_tool` for one flow, to follow an execution path.
+5. Call `find_large_functions_tool` to find oversized functions.
+6. Call `list_graph_stats_tool` only when you need node, edge and language counts.
+
+## Token Efficiency Rules
+- Call `get_minimal_context_tool(task="<your task>")` before any other graph tool.
+- Pass `detail_level="minimal"` wherever a tool accepts it. Use "standard" only when minimal is not enough.
+- Prefer a targeted `query_graph_tool` call over a broad listing call.
+- Budget: about five tool calls and 800 tokens of graph output per task.
+- Read the implementation and its tests before changing code. The graph narrows scope; it does not replace the source.

package/skills/refactor-safely/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: refactor-safely
+description: Plan and execute safe refactoring using dependency analysis
+---
+
+## Refactor Safely
+
+Plan a refactor from the dependency graph and apply renames from a preview.
+
+### Steps
+
+1. Call `refactor_tool` with `mode="suggest"` for refactoring candidates, or `mode="dead_code"` for unreferenced code.
+2. For a rename, call `refactor_tool` with `mode="rename"`, `old_name` and `new_name`. Check the returned edit list before applying.
+3. Call `apply_refactor_tool` with the returned `refactor_id` to apply the rename.
+4. Before a large refactor, call `get_impact_radius_tool` and `get_affected_flows_tool` to see the dependents and critical paths involved.
+5. Call `find_large_functions_tool` to find functions worth splitting.
+6. After the change, call `detect_changes_tool` to confirm the impact matches the plan.
+
+## Token Efficiency Rules
+- Call `get_minimal_context_tool(task="<your task>")` before any other graph tool.
+- Pass `detail_level="minimal"` wherever a tool accepts it. Use "standard" only when minimal is not enough.
+- Prefer a targeted `query_graph_tool` call over a broad listing call.
+- Budget: about five tool calls and 800 tokens of graph output per task.
+- Read the implementation and its tests before changing code. The graph narrows scope; it does not replace the source.

package/skills/review-changes/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: review-changes
+description: Perform a structured code review using change detection and impact
+---
+
+## Review Changes
+
+Review a change set with risk scores and blast radius from the knowledge graph.
+
+### Steps
+
+1. Call `detect_changes_tool` for risk-scored changed functions, test gaps and affected flows.
+2. Call `get_affected_flows_tool` only when you need the steps of an affected flow.
+3. For each high-risk function, call `query_graph_tool` with `pattern="tests_for"` to check test coverage.
+4. Call `get_impact_radius_tool` when the blast radius is not clear from step 1.
+5. Suggest specific test cases for untested changes.
+
+### Output Format
+
+Group findings by risk level (high, medium, low). For each finding give what changed and why it matters, its test coverage, and the suggested fix. End with a merge recommendation.
+
+## Token Efficiency Rules
+- Call `get_minimal_context_tool(task="<your task>")` before any other graph tool.
+- Pass `detail_level="minimal"` wherever a tool accepts it. Use "standard" only when minimal is not enough.
+- Prefer a targeted `query_graph_tool` call over a broad listing call.
+- Budget: about five tool calls and 800 tokens of graph output per task.
+- Read the implementation and its tests before changing code. The graph narrows scope; it does not replace the source.

package/skills/review-delta/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: review-delta
+description: Review only changes since last commit using impact analysis. Token-efficient delta review with automatic blast-radius detection.
+argument-hint: "[file or function name]"
+---
+
+# Review Delta
+
+Review only the changed code and its blast radius.
+
+## Steps
+
+1. Call `get_minimal_context_tool(task="review changes")`. If it returns `status: not_ready`, call `build_or_update_graph_tool()` and continue.
+2. Call `detect_changes_tool(detail_level="minimal")` for risk-scored changed functions, test gaps and affected flows. Changes come from `git diff` against `HEAD~1`; if the argument names a file, pass it in `changed_files`.
+3. Call `get_review_context_tool(detail_level="minimal")` when you need source snippets for the changed areas and `review_guidance` (untested functions, wide blast radius, inheritance changes).
+4. For each untested high-risk function, confirm with `query_graph_tool(pattern="tests_for", target="<function>")`.
+5. Use `detail_level="standard"` only for a high-risk item the minimal output leaves unclear. Do not load whole files unless a snippet is not enough.
+
+## Report
+
+- Summary: one line
+- Risk: low, medium or high, from the blast radius
+- Issues: bugs, missing tests, style
+- Blast radius: impacted files and functions
+- Recommendations

package/skills/review-pr/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: review-pr
+description: Review a PR or branch diff using the knowledge graph for full structural context. Outputs a structured review with blast-radius analysis.
+argument-hint: "[PR number or branch name]"
+---
+
+# Review PR
+
+Review all commits of a pull request or branch against its base branch.
+
+## Steps
+
+1. Identify the changes. With a branch name run `git diff --name-only main...<branch>`; otherwise diff the current branch against `main` (or `master`). Use that ref as `base` below.
+2. Call `get_minimal_context_tool(task="review PR", base="main")`. If it returns `status: not_ready`, call `build_or_update_graph_tool()` and continue.
+3. Call `detect_changes_tool(base="main", detail_level="minimal")` for risk-scored changed functions, test gaps and affected flows across the whole branch.
+4. For high-risk functions call `query_graph_tool(pattern="callers_of", target="<function>")` and `query_graph_tool(pattern="tests_for", target="<function>")`. Flag public API changes whose callers were not updated.
+5. Call `get_review_context_tool(base="main")` for source snippets, or `get_impact_radius_tool(base="main")` for the full dependent list, only when step 3 leaves a high-risk item unclear.
+6. Read the changed source of the highest-impact files first. Do not load whole files unless the change needs it.
+
+## Output
+
+```
+## PR Review: <title>
+
+### Summary
+<1-3 sentences>
+
+### Risk
+- Overall: Low / Medium / High
+- Blast radius: <n> files, <m> functions
+- Test coverage: <covered> of <changed> changed functions
+
+### Files
+#### <path>
+- Changes: <what>
+- Impact: <who depends on it>
+- Issues: <bugs, style, concerns>
+
+### Missing Tests
+- <function> in <file>
+
+### Recommendations
+1. <action>
+```
+
+## Tips
+
+- Use `semantic_search_nodes_tool` to find related code the PR may have missed.