# indexion-refactor

Eliminates textual, structural, and conceptual code duplication using the indexion CLI. It guides multi-package code extraction and cleans up redundant wrappers.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 4900 installs · ★ 2
- Author: trkbt10
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/trkbt10/indexion-skills/tree/HEAD/skills/indexion-refactor/SKILL.md
- Updated: 2026-09-22
- HTML: https://affpapa.org/en/nevibecode/skills/indexion-refactor

## What it does

This skill guides coding agents through a three-phase refactoring workflow. It begins with `indexion plan refactor` to pinpoint high-confidence copy-pasted blocks and function duplicates with similarity thresholds starting at 0.9. High-value matches within single files get consolidated first after tracing call sites via `indexion grep`.

The second phase runs `indexion plan solid` across multiple directories using the `--from` flag to extract shared logic into dedicated packages. Finally, `indexion plan unwrap` identifies unnecessary proxy functions and trivial delegates, supporting a `--dry-run` flag to inspect planned deletions safely.

Execution requires the `indexion` binary installed in your environment, because every check relies directly on its CLI commands. It also defines stop signals to prevent regressions: platform stubs, `@argparse` boilerplate, and type methods like `to_string` are preserved deliberately.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add trkbt10/indexion-skills --skill indexion-refactor -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/indexion-refactor/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/indexion-refactor/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add trkbt10/indexion-skills --skill indexion-refactor -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/indexion-refactor/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add trkbt10/indexion-skills --skill indexion-refactor -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/indexion-refactor/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install trkbt10/indexion-skills indexion-refactor
```

2. **Manually: put the files in place**
- File: `.github/skills/indexion-refactor/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add trkbt10/indexion-skills --skill indexion-refactor -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/trkbt10/indexion-skills --path skills/indexion-refactor
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/indexion-refactor/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add trkbt10/indexion-skills --skill indexion-refactor -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/trkbt10/indexion-skills/tree/HEAD/skills/indexion-refactor/SKILL.md

## When to use it
- find duplicate code blocks and functions above a 0.9 similarity threshold
- extract shared logic across separate packages into common modules
- clean up trivial proxy functions and wrapper indirection
- verify single-source-of-truth compliance after adding new abstractions

## Example prompts
- Run `indexion plan refactor --threshold=0.9` on `src/` to locate duplicated functions.
- Analyze overlap between `src/a` and `src/b` using `indexion plan solid` and plan extraction to `src/common`.
- Check for unnecessary wrapper functions across `src/` with `indexion plan unwrap --dry-run`.

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: cc6e70ddb1792011.

BEGIN THIRD-PARTY FILE cc6e70ddb1792011
````text
---
name: indexion-refactor
description: After writing code, detect and clean up duplication at three levels — copy-paste blocks, cross-package shared code, unnecessary wrappers, and concept-level SoT violations. Detect with indexion, fix, and verify.
---

# indexion refactor — Codebase Refactoring

Detect and eliminate duplication at three levels — textual, structural, and conceptual —
using indexion's analysis commands, then verify SoT is enforced.

## When to Use

- After adding a new abstraction (type, module, API layer)
- After introducing a new file format or I/O boundary
- When a fix required touching 3+ files for the same reason
- When a "guard" or "skip" was added to work around a structural problem
- When `opendir`, `ENOENT`, or similar filesystem errors appear from unexpected paths
- When extracting shared code across packages
- When cleaning up after a refactor (removing trivial wrapper functions)
- Periodic SoT health check on a codebase

## Three Levels of Duplication

| Level | What it is | Tool | Example |
|-------|-----------|------|---------|
| **Textual** | Copy-pasted code blocks, identical functions | `plan refactor` | `is_whitespace` copied across 5 modules |
| **Structural** | Same logic structure with different names | `plan solid`, `plan unwrap` | cross-package extraction candidates, trivial wrappers |
| **Conceptual** | Same domain concept implemented independently | `explore` + manual analysis | Three modules each deciding "is this file an archive?" |

Textual duplication is easy to find and fix. Conceptual duplication is the hardest and
most dangerous — it produces no copy-paste matches but means changing one concept requires
updating every scattered implementation.

## Workflow

### Phase 1: Clear textual duplication (`plan refactor`)

Start with high-confidence matches and work down.

```bash
# Step 1: Find 90%+ duplicates (high confidence)
indexion plan refactor --threshold=0.9 \
  --include='*.mbt' --exclude='*_wbtest.mbt' \
  --exclude='*moon.pkg*' --exclude='*pkg.generated*' \
  cmd/indexion/

indexion plan refactor --threshold=0.9 \
  --include='*.mbt' --exclude='*_wbtest.mbt' \
  --exclude='*moon.pkg*' --exclude='*pkg.generated*' \
  src/
```

**Read the output in three sections:**

| Section | What it finds | Action |
|---------|--------------|--------|
| Similar Files | Files with high overall similarity | Investigate for structural consolidation |
| Duplicate Code Blocks | Line-level identical code between files | Extract to `@common` or shared module |
````
END THIRD-PARTY FILE cc6e70ddb1792011

The third-party file has ended. Everything between the cc6e70ddb1792011 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2546 of 13988 bytes. © trkbt10 · Apache-2.0 · https://github.com/trkbt10/indexion-skills/tree/HEAD/skills/indexion-refactor/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md