OpenRuna
Sign in
SKILL.md

name: gitnexus-refactoring description: "Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file""

Refactoring with GitNexus

When to Use

  • "Rename this function safely"
  • "Extract this into a module"
  • "Split this service"
  • "Move this to a new file"
  • Any task involving renaming, extracting, splitting, or restructuring code

Workflow

1. gitnexus_impact({target: "X", direction: "upstream"})  → Map all dependents
2. gitnexus_query({query: "X"})                            → Find execution flows involving X
3. gitnexus_context({name: "X"})                           → See all incoming/outgoing refs
4. Plan update order: interfaces → implementations → callers → tests

If "Index is stale" → run npx gitnexus analyze in terminal.

Checklists

Rename Symbol

- [ ] gitnexus_rename({symbol_name: "oldName", new_name: "newName", dry_run: true}) — preview all edits
- [ ] Review graph edits (high confidence) and ast_search edits (review carefully)
- [ ] If satisfied: gitnexus_rename({..., dry_run: false}) — apply edits
- [ ] gitnexus_detect_changes() — verify only expected files changed
- [ ] Run tests for affected processes

Extract Module

- [ ] gitnexus_context({name: target}) — see all incoming/outgoing refs
- [ ] gitnexus_impact({target, direction: "upstream"}) — find all external callers
- [ ] Define new module interface
- [ ] Extract code, update imports
- [ ] gitnexus_detect_changes() — verify affected scope
- [ ] Run tests for affected processes

Split Function/Service

- [ ] gitnexus_context({name: target}) — understand all callees
- [ ] Group callees by responsibility
- [ ] gitnexus_impact({target, direction: "upstream"}) — map callers to update
- [ ] Create new functions/services
- [ ] Update callers
- [ ] gitnexus_detect_changes() — verify affected scope
- [ ] Run tests for affected processes

Tools

gitnexus_rename — automated multi-file rename:

gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true})
→ 12 edits across 8 files
→ 10 graph edits (high confidence), 2 ast_search edits (review)
→ Changes: [{file_path, edits: [{line, old_text, new_text, confidence}]}]

gitnexus_impact — map all dependents first:

gitnexus_impact({target: "validateUser", direction: "upstream"})
→ d=1: loginHandler, apiMiddleware, testUtils
→ Affected Processes: LoginFlow, TokenRefresh

gitnexus_detect_changes — verify your changes after refactoring:

gitnexus_detect_changes({scope: "all"})
→ Changed: 8 files, 12 symbols
→ Affected processes: LoginFlow, TokenRefresh
→ Risk: MEDIUM

gitnexus_cypher — custom reference queries:

MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "validateUser"})
RETURN caller.name, caller.filePath ORDER BY caller.filePath

Risk Rules

Risk FactorMitigation
Many callers (>5)Use gitnexus_rename for automated updates
Cross-area refsUse detect_changes after to verify scope
String/dynamic refsgitnexus_query to find them
External/public APIVersion and deprecate properly

Example: Rename validateUser to authenticateUser

1. gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: true})
   → 12 edits: 10 graph (safe), 2 ast_search (review)
   → Files: validator.ts, login.ts, middleware.ts, config.json...

2. Review ast_search edits (config.json: dynamic reference!)

3. gitnexus_rename({symbol_name: "validateUser", new_name: "authenticateUser", dry_run: false})
   → Applied 12 edits across 8 files

4. gitnexus_detect_changes({scope: "all"})
   → Affected: LoginFlow, TokenRefresh
   → Risk: MEDIUM — run tests for these flows

Overview

Free skill — gitnexus-refactoring. Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Mo

What this skill does

Looking for a dependable skill? "gitnexus-refactoring" gives you a tested starting point instead of a blank prompt box. Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file" On OpenRuna it sits inside a connected graph of related skills, tools, and datasets, so branching into adjacent resources is one click away. Copy it into your assistant of choice and sharpen the result with a couple of follow-up turns.

Use cases

  • Use "gitnexus-refactoring" when you need a repeatable skill for professional work without rewriting instructions every time.
  • Hand "gitnexus-refactoring" to a new teammate so their skill output matches your team's quality bar from day one.
  • Combine it with related tools and prompts in the same OpenRuna category to build an end-to-end workflow.
  • Reach for it during planning or review sessions when you want consistent, AI-assisted structure.

Example output

Running this skill produces output shaped like the source material below:

# Refactoring with GitNexus

## When to Use

- "Rename this function safely"
- "Extract this into a module"
- "Split this service"
- "Move this to a new file"
- Any task involving renaming, extracting, splitting, or restructuring code

## Workflow

```
1. gitnexus_impact({target: "X", direction: "upstream"})  → Map all dependents
2. gitnexus_query({query: "X"})                            → Find execution flows involving X
3. gitnexus_context({name: "X"})                           → See all incoming/outgoing refs
4. Plan update order: interfaces → implementations → callers → tests
```

> If "In…

Results vary by model and temperature; treat the first response as a draft and refine it with follow-up prompts.

Tips by platform

Claude

Claude works best when you paste this skill up front and ask it to outline its plan before writing. Use the artifact panel to refine structured output turn by turn.

ChatGPT

For ChatGPT, save this skill as a Custom Instruction or a saved prompt so it is one click away. Add your specifics in a follow-up rather than editing the original.

Cursor

Cursor users can store this skill as a project rule so Agent mode applies it automatically. Mention it with @ when you want it scoped to a single task.

Frequently asked questions

What is "gitnexus-refactoring"?
It is a skill listed on OpenRuna — Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file" You can copy and adapt it for ChatGPT, Claude, Cursor, or any other AI assistant.
Is "gitnexus-refactoring" free to use?
Most OpenRuna resources are open or CC0-licensed. Check the license shown on this page before commercial use; premium collections are clearly marked as such.
How do I get the best results from this skill?
Replace any placeholders, add your project context, and ask the model to confirm its assumptions first. Iterate over 2–3 follow-up turns rather than expecting a perfect first response.
Does "gitnexus-refactoring" work with both Claude and ChatGPT?
Yes — it is model-agnostic text, so it runs on Claude, ChatGPT, Gemini, and Cursor. The tips on this page cover each of those assistants specifically.
Where can I find resources related to "gitnexus-refactoring"?
Scroll to the Related resources section on this page, or open the matching category hub on OpenRuna to find connected prompts, tools, agents, and datasets in the same topic area.

Related resources