Przejdź do treści
Biblioteka skilli
Programowanie · Research

coderlm

/coderlm

Zapewnia strukturalną nawigację po kodzie w wielu językach (Rust, Python, TypeScript, Go, Java i inne) z indeksem opartym na tree-sitter: symbole po nazwie, ciała funkcji, łańcuchy wywołań i testy.

Repozytorium
coderlm ↗
Licencja
MIT
Ostatnia zmiana repozytorium
04.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 04.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/coderlm_cli.py

Co robi i kiedy

Zapewnia strukturalną nawigację po kodzie w wielu językach (Rust, Python, TypeScript, Go, Java i inne) z indeksem opartym na tree-sitter: symbole po nazwie, ciała funkcji, łańcuchy wywołań i testy.

Wyzwalacze z opisu

what calls Xhow does X workwhere is X defined
Oryginalny opis (EN)

Structural codebase navigation for supported languages (Rust, Python, TypeScript, JavaScript, Go, Java, Scala, Ruby, PHP, Zig, SQL). Provides tree-sitter-backed indexing: find symbols by name, get exact function bodies, follow caller chains, discover tests. Works best combined with the Read tool: use coderlm CLI (`search`, `impl`, `callers`) to locate the right code across a codebase, then `Read` the identified files directly for full context. Use for: tracing execution paths across multiple files, answering 'what calls X', 'how does X work', 'where is X defined'. Avoid raw bash grep/find — us

Jak działa

  1. FIRST: Choose Your Mode
  2. Setup
  3. Quick Lookups: One-Off Commands
  4. Multiple Lookups: Batch Mode
  5. Multiple Lookups: Python Exec Mode
  6. Commands
  7. Fallback Rules (coderlm only — not raw bash)
  8. Output Requirements
  9. Inputs
Sekcje z nagłówków SKILL.md, w oryginale · 112 linii, 658 słów
Podgląd SKILL.md
---
name: coderlm
description: "Structural codebase navigation for supported languages (Rust, Python, TypeScript, JavaScript, Go, Java, Scala, Ruby, PHP, Zig, SQL). Provides tree-sitter-backed indexing: find symbols by name, get exact function bodies, follow caller chains, discover tests. Works best combined with the Read tool: use coderlm CLI (`search`, `impl`, `callers`) to locate the right code across a codebase, then `Read` the identified files directly for full context. Use for: tracing execution paths across multiple files, answering 'what calls X', 'how does X work', 'where is X defined'. Avoid raw bash grep/find — use the coderlm `grep` command instead."
allowed-tools:
  - Bash
  - Read
  - Agent
---

# CodeRLM — Structural Codebase Exploration

You have access to a tree-sitter-backed index server. Use it instead of guessing with grep.

## FIRST: Choose Your Mode

**Is the question "how does X work", "trace X", or "follow the execution path of X"?**

→ **Delegate immediately to a subcall agent. Do not do any CLI searches first.**

```
Agent(coderlm-subcall, "Trace how <X> works. Find the entrypoint, follow callers, and show the full execution path with code extracts.")
```

The subcall agent has a structured workflow for tracing and will return findings with code evidence. Using it keeps the full exploration out of your context window and produces more complete results than piecemeal CLI calls.

**Is the question a targeted lookup ("where is X defined", "what calls X", "show me X")?**

→ Use CLI commands directly (see below).

**When to just Read a file directly.** After 1-2 `search` or `structure` calls, if the relevant code is clearly concentrated in 1-3 files, **Read those files directly** instead of reconstructing them with granular CLI calls. Read is cheaper than 10+ `impl`/`symbols`/`peek` calls for a focused file. Only keep using CLI lookups when tracing across many files (5+) or when you need symbol-level precision that Read can't give you.

**NEVER fall back to raw bash grep/find/cat.** If a coderlm CLI command fails, use the coderlm fallback rules — not shell tools.

---

## Setup

```bash
CLI=".claude/coderlm_state/coderlm_cli.py"
```

Session is auto-created by the plugin. If not, run `python3 $CLI init`.

## Quick Lookups: One-Off Commands

For a single targeted lookup:

```bash
python3 $CLI search MyFunction
python3 $CLI impl MyFunction --file path/to/file.py
python3 $CLI callers MyFunction --file path/to/file.py
```

## Multiple Lookups: Batch Mode

For 2-5 targeted lookups, use batch to minimize tool calls:

```bash
python3 $CLI batch --commands "
search MyFunction
impl MyFunction --file path/to/file.py
callers MyFunction --file path/to/file.py
"
```

## Multiple Lookups: Python Exec Mode

For tracing a full execution path in one shot — search, then follow callers up the chain:

```bash
python3 $CLI exec --code "
# Find entrypoint, read its implementation, then walk callers up the chain
hits = search('serialize_response')
if hits.get('symbols'):
    sym = hits['symbols'][0]
    impl_(sym['name'], sym['file'])                    # read the function
    c = callers(sym['name'], sym['file'])               # find who calls it
    if c.get('callers'):
        caller = c['callers'][0]
        impl_(caller['name'], caller['file'])           # read the caller
        callers(caller['name'], caller['file'])         # one more hop up
"
```

Use exec mode when you need to: follow a call chain across 3+ hops, or make later queries depend on earlier results. One exec call replaces many individual Bash calls and keeps the full trace in a single result.

Available helpers in exec mode: `search()`, `impl_()`, `callers()`, `tests()`, `grep()`, `symbols()`, `peek_file()`, `structure()`, `variables_list()`.

## Commands

| Command | Purpose |
|---------|---------|
| `search QUERY [--file FILE]` | Find symbols by name |
| `impl SYMBOL --file FILE` | Get full source code |
| `callers SYMBOL --file FILE` | Find call sites |
| `tests SYMBOL --file FILE` | Find tests referencing symbol |
| `grep PATTERN [--scope code] [--file FILE]` | Regex search (`--scope code` skips comments) |
| `peek FILE --start N --end N` | Read a line range |
| `symbols [--file FILE] [--kind KIND]` | List all symbols |
| `structure [--depth N]` | Project file tree |

## Fallback Rules (coderlm only — not raw bash)

- `search` returns 0 → use `grep` for the name
- `impl` fails (404) → use `peek` with the file path
- `callers` returns nothing → `grep` for the symbol name
- Don't retry failures — pivot to an alternative

## Output Requirements

1. **Code extracts** — Include actual source from `impl` or `peek` as fenced code blocks
2. **File:line references** — Cite specific locations for every claim
3. **Chain of evidence** — Show each hop when tracing execution paths

## Inputs

This skill reads `$ARGUMENTS`. Accepted patterns:
- `query=<question>` (required): what to find or understand
- `cwd=<path>` (optional): project directory
- `port=<N>` (optional): server port (default: 3000)
Pliki w paczce (3)
  • SKILL.md 5 KB
  • references/api-reference.md 10 KB
  • scripts/coderlm_cli.py 23 KB

Wersje

W bazie nie ma innych skilli o nazwie coderlm.

Migawka bazy z 13.11.2026 · wersja paczki e9b53988610f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100code-symbols
    Wyszukuje i edytuje symbole w kodzie za pomocą ast-grep opartego na tree-sitter: definicje, użycia, zmiany nazw i zastępowanie kodu w JavaScript, TypeScript, Python, Go, Rust i innych językach.
  • 100codemapper
    Analizuje strukturę kodu natychmiast dzięki drzewom AST z tree-sitter: znajduje symbole, śledzi ścieżki wywołań, sprawdza pokrycie testami i zależności w Pythonie, JavaScripcie, TypeScripcie, Rust, Java, Go i C.
  • 100tree-sitter-language-pack
    Parsuje kod w 372 językach przez gramatyki tree-sitter i wyciąga z niego symbole, importy oraz komentarze.
  • 84tree-sitter-language-pack
    Parsuje kod w 372 językach przez gramatyki tree-sitter i wydobywa strukturę, importy, symbole oraz diagnostykę składni.
  • 100tree-sitting
    Nawiguje po lokalnym repozytorium na poziomie symboli przez drzewa AST tree-sitter: definicje, zakresy linii, symbole pliku, zawartość katalogu i miejsca użycia nazwy.
  • 100ast-grep
    Pisze, debuguje i waliduje reguły ast-grep do wyszukiwania kodu świadomego składni, w tym funkcji z określonymi potomkami, wywołań w kontekście i dekoratorów w strukturach Tree-sitter.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.