Skip to content
Skills Library
Programming · Analysis

codemapper

/codemapper

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

Repository
dotfiles ↗
Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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

Original author 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

How it works

  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
Original SKILL.md headings · 155 lines, 713 words
SKILL.md preview
---
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)
Files in this package (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

Versions

The database has no other skills named codemapper.

Database snapshot: 13.11.2026 · package version 8edadb640cba (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100code-symbols
    Find and edit symbols in code using ast-grep (tree-sitter based). Use when finding function definitions, class definitions, symbol usages, renaming symbols, or replacing code in JavaScript, TypeScript, Python, Go, Rust, and other languages. NOT for Clojure - use clj-symbols instead.
  • 100coderlm
    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…
  • 84tree-sitter-language-pack
    Parse and extract code intelligence from 372 programming languages using tree-sitter grammars. Use when writing code that parses source, extracts structure/imports/exports/symbols/docstrings/comments, detects a language, runs syntax diagnostics, or produces syntax-aware chunks…
  • 100graph-build
    Builds or updates the code knowledge graph via tree-sitter AST and SQLite. Use when setting up the graph before search or blast-radius analysis.
  • 100tree-sitter-language-pack
    Parse and extract code intelligence from 372 programming languages using tree-sitter grammars. Use when writing code that parses source, extracts structure/imports/exports/symbols/docstrings/comments, detects a language, runs syntax diagnostics, or produces syntax-aware chunks…
  • 100ast-grep
    Write, debug, and validate ast-grep structural code search rules. Use for syntax-aware code search, AST pattern matching, structural refactor discovery, or searches plain text tools like rg can miss — functions with particular descendants, calls inside specific contexts,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.