gitnexus-refactoring

Renames and restructures symbols while preserving references across repositories.

92|8|Updated May 15, 2026
One-click install
npx skills add https://github.com/LonelyHerbivore/Trellis-Herbivore --skill gitnexus-refactoring-lonelyherbivore
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gitnexus-refactoring
Source: https://github.com/LonelyHerbivore/Trellis-Herbivore/tree/main/.claude/skills/gitnexus/gitnexus-refactoring
Command: npx skills add https://github.com/LonelyHerbivore/Trellis-Herbivore --skill gitnexus-refactoring-lonelyherbivore

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you refactor by renaming, extracting, splitting, or moving code in a way that reduces breakage from missed dependencies and incorrect update ordering.

Core Features & Use Cases

  • Safe multi-file refactors: performs structured edits for renames and restructures, with confidence levels and targeted review where needed.
  • Impact-first planning: maps upstream/downstream dependents and execution flows so you update interfaces and callers in the correct order.
  • Change verification: detects and validates the actual files/symbols/processes affected so you can confirm the refactor stayed within the intended scope.
  • Use cases: rename a critical function, extract logic into a new module, split a service into smaller responsibilities, or move code into a new file while keeping references consistent.

Quick Start

Use gitnexus-refactoring to rename this symbol safely by previewing changes first, then apply edits only after checking the dependency graph and confirming the detected scope.

Frequently Asked Questions about gitnexus-refactoring

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I safely rename a function across multiple files without breaking references?

To safely rename a function, map the dependency graph to identify all upstream and downstream callers, then apply ordered updates covering interfaces, implementations, and tests to preserve correct references.

What's the best way to extract a module or split a service while keeping callers consistent?

Extracting a module or splitting a service requires impact-first planning to detect affected execution flows, followed by ordered edits to move code into new files while updating dependent callers and validating the change scope.

Does this refactoring approach verify that structural edits stayed within the intended scope?

Yes, change verification detects and validates the actual files, symbols, and processes affected by the refactor, allowing you to confirm that structural edits and symbol renames remained within the intended scope.

How do I preview changes before applying a multi-file code restructuring?

You can preview changes by inspecting the dependency impact mapping and context first, then apply structured edits only after confirming the detected scope and confidence levels for the targeted review.

Can I use this for moving code to a new file with dependent callers updated in order?

Yes, moving code to a new file is supported by performing ordered updates across dependent callers, ensuring that interfaces, implementations, and tests are restructured sequentially to maintain reference consistency.

Why does a refactor break when I miss dependencies and use incorrect update ordering?

Refactors break when upstream and downstream dependents are not mapped first, causing missed references; applying structured edits with impact-first planning ensures interfaces, implementations, and callers are updated in the correct order.