gitnexus-refactoring

Rename, extract, split, or move code symbols with dependency-aware impact analysis.

2|Updated May 15, 2026
One-click install
npx skills add https://github.com/lNwNl/Methodos --skill gitnexus-refactoring-lnwnl
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: gitnexus-refactoring
Source: https://github.com/lNwNl/Methodos/tree/main/.claude/skills/gitnexus/gitnexus-refactoring
Command: npx skills add https://github.com/lNwNl/Methodos --skill gitnexus-refactoring-lnwnl

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Refactoring code often breaks hidden dependencies, call graphs, and dynamic references, making changes risky and hard to validate.

Core Features & Use Cases

  • Safe rename and restructure guidance: Renames, extracts, splits, moves, and restructures symbols with an order of operations that reduces breakage (interfaces → implementations → callers → tests).
  • Graph-driven impact analysis: Maps dependents and execution flows so you update all affected areas instead of guessing.
  • Context-aware refactoring checks: Uses incoming/outgoing reference context and validates the scope of changes before and after applying edits.
  • Risk-focused mitigation: Flags scenarios like many callers and cross-area refs, and recommends verification via change detection and affected-process testing.
  • Index freshness handling: Advises running an analysis command when the index is stale to ensure accurate results.

Quick Start

Use gitnexus-refactoring when you want to rename a symbol safely across the codebase by first previewing edits with a dry run, then applying changes, then verifying the affected scope and running the relevant tests.

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 symbol across a large codebase without breaking call sites?▼

To safely rename symbols without breaking call sites, compute a dependency-aware impact graph first, preview edits via a dry run, apply changes from interfaces to implementations, then update callers and tests.

What is the best way to calculate dependency impact before extracting or moving code?▼

Calculating dependency impact requires graph-driven analysis that maps dependents and execution flows, ensuring you update all affected areas and validate cross-module references before extracting or moving code.

How do I verify code changes after splitting functions or updating interfaces?▼

Verify code changes after splitting functions by running change detection on the affected scope and executing relevant tests to confirm execution flows remain intact across all updated caller sites.

Can I preview refactoring edits before applying them to cross-module references?▼

Yes, you can preview refactoring edits before applying them by using a dry-run mode that detects changes and validates the scope of cross-module references without modifying the actual codebase.

Why do refactoring operations fail when the code graph index is stale?▼

Refactoring operations fail or produce inaccurate results when the code graph index is stale, so you must run a fresh analysis command to rebuild the index and ensure accurate dependency mapping.

When should I not use automated refactoring for dynamic references?▼

Avoid automated refactoring for dynamic references when risk-focused mitigation flags many callers or cross-area dependencies, requiring manual verification via change detection and affected-process testing instead.