Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

codemapper

/codemapper

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.

Repozytorium
dotfiles ↗
Licencja
MIT
Ostatnia zmiana repozytorium
26.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
6
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.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 robi i kiedy

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.

Oryginalny opis (EN)

Use when analyzing codebases for structure, finding symbols, tracing call paths, checking test coverage, or analyzing dependencies - provides instant AST-based code analysis using tree-sitter for Python, JavaScript, TypeScript, Rust, Java, Go, and C

Jak działa

  1. Overview
  2. When to Use
  3. Quick Start
  4. Essential Commands
  5. Key Workflows
  6. Common Mistakes
  7. Best Practices
  8. Troubleshooting
  9. Reference Documentation
  10. Performance
Sekcje z nagłówków SKILL.md, w oryginale · 155 linii, 713 słów
Podgląd SKILL.md
---
name: codemapper
description: Use when analyzing codebases for structure, finding symbols, tracing call paths, checking test coverage, or analyzing dependencies - provides instant AST-based code analysis using tree-sitter for Python, JavaScript, TypeScript, Rust, Java, Go, and C
---

# CodeMapper (cm) - Fast Code Analysis

## Overview

CodeMapper (`cm`) uses tree-sitter AST parsing to provide instant code analysis without databases. Get project structure, find symbols, trace call graphs, and analyze dependencies in milliseconds.

**Supported Languages:** Python, JavaScript, TypeScript, Rust, Java, Go, C, Markdown

## When to Use

Use CodeMapper when you need to:
- ✅ Explore unfamiliar codebases (get overview, find structure)
- ✅ Find symbol definitions and usages (functions, classes, methods)
- ✅ Understand call graphs (who calls what, call paths)
- ✅ Check test coverage (find untested code)
- ✅ Analyze git changes at symbol level (breaking changes)
- ✅ Pre-refactoring impact analysis (understand dependencies)

**Don't use for:**
- ❌ Full-text search (use ripgrep/grep instead)
- ❌ Runtime analysis (use profilers)
- ❌ Code execution (use interpreters/compilers)

## Quick Start

```bash
# Step 1: Get overview
cm stats .

# Step 2: See file structure (ALWAYS use --format ai for LLMs)
cm map . --level 2 --format ai

# Step 3: Find specific code
cm query <symbol> --format ai

# Step 4: Deep dive into a file
cm inspect ./path/to/file --format ai
```

**🔥 CRITICAL: Always use `--format ai` when analyzing code for LLM context. This is the most token-efficient format (60-80% reduction).**

## Essential Commands

| Task | Command |
|------|---------|
| Project overview | `cm stats .` |
| File structure | `cm map . --level 2 --format ai` |
| Find symbol | `cm query <name> --format ai` |
| Show implementation | `cm query <name> --show-body --format ai` |
| Who calls it? | `cm callers <symbol> --format ai` |
| What does it call? | `cm callees <symbol> --format ai` |
| Call path A→B | `cm trace <from> <to> --format ai` |
| Find tests | `cm tests <symbol> --format ai` |
| Untested code | `cm untested . --format ai` |
| Breaking changes | `cm since <commit> --breaking --format ai` |

**For complete command reference:** Read `references/command-reference.md`

## Key Workflows

### Exploring Unknown Code
```bash
cm stats .
cm map . --level 2 --format ai
cm query <symbol> --format ai
```

### Before Refactoring
```bash
cm callers <function> --format ai      # Who depends on this?
cm tests <function> --format ai        # Is it tested?
cm callees <function> --format ai      # What does it depend on?
```

### Code Health Check
```bash
cm untested . --format ai                       # What's not tested?
cm since <last_release> --breaking --format ai  # Breaking changes?
```

**For detailed workflows:** Read `references/workflows.md`

## Common Mistakes

### ❌ Forgetting `--format ai`
```bash
# Bad (verbose, token-heavy)
cm map . --level 2

# Good (compact, LLM-optimized)
cm map . --level 2 --format ai
```

### ❌ Using grep for call graphs
```bash
# Bad (misses indirect calls, false positives)
grep -r "process_payment"

# Good (accurate AST-based call graph)
cm callers process_payment --format ai
```

### ❌ Skipping stats/map
```bash
# Bad (jumping to query without context)
cm query something --format ai

# Good (understand structure first)
cm stats .
cm map . --level 2 --format ai
cm query something --format ai
```

**For more examples:** Read `references/common-mistakes.md`

## Best Practices

1. **Always start with overview:** `cm stats .` then `cm map . --level 2 --format ai`
2. **Always use `--format ai` for LLMs:** Token efficiency matters
3. **Fuzzy search first:** Default fuzzy matching is more forgiving
4. **Check before refactoring:** Run `cm callers` and `cm tests` before changes
5. **Use correct tool:** CodeMapper for structure/calls, ripgrep for text search

## Troubleshooting

**No Symbols Found?**
- Check file extensions: `cm stats .` shows what's indexed
- Try fuzzy search (default) vs `--exact`

**Slow Queries?**
- First run builds cache (~10s)
- Subsequent runs use cache (~0.5s)

**Git Commands Fail?**
- Must be in a git repository for: `diff`, `since`, `blame`, `history`

**For detailed troubleshooting:** Read `references/troubleshooting.md`

## Reference Documentation

- **`references/command-reference.md`** - Complete command and flag reference
- **`references/workflows.md`** - Detailed workflow patterns for common tasks
- **`references/common-mistakes.md`** - Extended examples of what to avoid
- **`references/troubleshooting.md`** - Comprehensive troubleshooting guide
- **`references/integration-examples.md`** - CI/CD, documentation, code review patterns

## Performance

- **Small repos** (< 100 files): < 20ms instant
- **Medium repos** (100-1000): ~0.5s with cache
- **Large repos** (1000+): Fast mode auto-enabled

Cache location: `.codemapper/` in project root (auto-managed)
Pliki w paczce (6)
  • SKILL.md 5 KB
  • references/command-reference.md 8 KB
  • references/common-mistakes.md 11 KB
  • references/integration-examples.md 15 KB
  • references/troubleshooting.md 12 KB
  • references/workflows.md 10 KB

Wersje

W bazie nie ma innych skilli o nazwie codemapper.

Migawka bazy z 13.11.2026 · wersja paczki 8edadb640cba (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.
  • 100coderlm
    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.
  • 84tree-sitter-language-pack
    Parsuje kod w 372 językach przez gramatyki tree-sitter i wydobywa strukturę, importy, symbole oraz diagnostykę składni.
  • 100graph-build
    Buduje lub aktualizuje graf wiedzy o kodzie przez tree-sitter AST i SQLite, przed wyszukiwaniem i analizą zasięgu zmian.
  • 100tree-sitter-language-pack
    Parsuje kod w 372 językach przez gramatyki tree-sitter i wyciąga z niego symbole, importy oraz komentarze.
  • 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.