Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

rescue-map

/rescue-map

Mapuje nieznany kod przed zmianami: języki, punkty wejścia, budowanie i testy, granice modułów, magazyny danych i zmienne środowiskowe, z odniesieniami do plików.

Licencja
MIT
Ostatnia zmiana repozytorium
07.11.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
2
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.11.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: inventory.py

Co robi i kiedy

Mapuje nieznany kod przed zmianami: języki, punkty wejścia, budowanie i testy, granice modułów, magazyny danych i zmienne środowiskowe, z odniesieniami do plików.

Wyzwalacze z opisu

where to start readingI just inherited this codebasemap this repowhere do I even starthow is this project laid outwhat does this app talk toexplain the architecture of this legacy apponboard me to this repo

Argumenty

/rescue-map [path to repo or sub-folder, default .]
Oryginalny opis (EN)

Maps an unfamiliar codebase before anyone changes it: languages, entry points, how to build, run and test it, module boundaries, data stores, external services and the environment variables it needs. Writes rescue/map.md with a mermaid module diagram and a "where to start reading" list, every claim tied to a file path. Read-only. Use when the user says "I just inherited this codebase", "map this repo", "where do I even start", "how is this project laid out", "what does this app talk to", "explain the architecture of this legacy app", or "onboard me to this repo".

Jak działa

  1. Inputs
  2. Output
  3. Steps
  4. Template for rescue/map.md
  5. In one paragraph
  6. Stack
  7. How to build, run and test
  8. Entry points
  9. Modules
  10. Data stores and external services
Sekcje z nagłówków SKILL.md, w oryginale · 139 linii, 1 023 słów
Podgląd SKILL.md
---
name: rescue-map
description: >-
  Maps an unfamiliar codebase before anyone changes it: languages, entry points, how to
  build, run and test it, module boundaries, data stores, external services and the
  environment variables it needs. Writes rescue/map.md with a mermaid module diagram and
  a "where to start reading" list, every claim tied to a file path. Read-only. Use when
  the user says "I just inherited this codebase", "map this repo", "where do I even start",
  "how is this project laid out", "what does this app talk to", "explain the architecture
  of this legacy app", or "onboard me to this repo".
argument-hint: "[path to repo or sub-folder, default .]"
---

# rescue-map

You are drawing the map before the rescue. Nobody fixes what they cannot find. This skill
reads the repository, never runs or changes it, and writes one document a new maintainer can
trust: what the system is made of, how to start it, what it depends on, and which twenty files
to read first. Every statement in the map points at a file. If you could not confirm
something, it goes under "Unknowns", not into the map.

## Inputs

- `$ARGUMENTS`: path to the repository or a sub-folder. Default: the current directory.
- Optional: anything the user already knows ("it is a Django monolith", "prod runs on ECS").
  Treat it as a claim to verify, not a fact.

## Output

- `rescue/map.md` in the user's repository (create `rescue/` if needed).
- `rescue/inventory.md`, the raw output of the inventory script, kept as evidence.

## Steps

1. **Check the ground.** Run `git status --short | head -20` and `git log -1 --format='%h %ad %an' --date=short`.
   Note uncommitted changes and the age of the last commit. If the folder is not a git repo,
   say so; later skills (hotspots) need history.

2. **Take the inventory.** Run:
   ```
   python3 "${CLAUDE_SKILL_DIR}/inventory.py" <path> --output rescue/inventory.md
   ```
   It lists languages, top-level directories with sizes, manifests, CI and container files,
   declared commands (package.json scripts, Makefile targets, Procfile), likely entry points,
   environment variables the code reads and keyword hints of data stores and services. Skip
   extra vendored folders with `--skip <name>`. On Windows use `python` if `python3` is missing.

3. **Read the front door.** Read, in this order, whichever exist: README, CONTRIBUTING, docs/
   index, the main manifest (package.json, pyproject.toml, pom.xml, go.mod, *.csproj, Gemfile),
   Dockerfile and compose files, CI workflow files. CI is the most honest documentation of how
   the project is really built and tested; prefer it over the README when they disagree, and
   record the disagreement.

4. **Pin the commands.** Fill a table of build, run, test, lint and migrate commands. For each,
   give the source (CI file line, script name, README section). Mark any command you only
   inferred as `(inferred)`. Do not run them here; `rescue-characterize` will run the tests.

5. **Trace the entry points.** For each likely entry point from the inventory, open it and
   follow one level down: what it wires up (routes, CLI commands, job handlers, message
   consumers, cron schedules). Use Grep for registration patterns such as `app.get(`,
   `@app.route`, `urlpatterns`, `@RestController`, `router.`, `consumer`, `schedule`, `cron`.

6. **Find the module boundaries.** Start from top-level and second-level directories. For each
   candidate module, Grep its imports to see what it depends on. Draw edges only for
   dependencies you saw in an import, include, require or call; label each edge with one
   example file. More than about 12 nodes: group the leaves.

7. **List data stores and external services.** Confirm each keyword hint from the inventory by
   opening the file: a connection string, client construction, ORM config or HTTP base URL.
   Drop hints you cannot confirm. For each confirmed one record: what it is, where it is
   configured, which env vars it needs, which modules touch it.

8. **List configuration.** From the inventory env var table plus config files, list every
   variable with where it is read, whether a default exists in code, and whether it looks like
   a secret (name contains KEY, SECRET, TOKEN, PASSWORD, DSN). Never print secret values,
   even if a committed .env file contains them; instead record "secret committed in <file>"
   as a risk.

9. **Pick where to start reading.** Choose 10 to 20 files in reading order: entry point,
   the router or dispatcher, the two or three busiest domain modules, the data access layer,
   one representative test. One line each on why it matters.

10. **Write `rescue/map.md`** using the template below, then tell the user the three most
    surprising findings and the next step.

## Template for rescue/map.md

~~~markdown
# System map: <repo name>
Mapped <date> at commit <short sha>. Read-only survey; nothing was run or changed.

## In one paragraph
<what this system does, for whom, in plain words, with the evidence file>

## Stack
| Layer | Technology | Evidence |

## How to build, run and test
| Task | Command | Source |

## Entry points
| Entry | Kind (HTTP, CLI, job, consumer) | File |

## Modules
```mermaid
graph LR
  web[web/ - HTTP handlers] --> orders[orders/ - pricing, checkout]
  orders --> db[(PostgreSQL)]
```
| Module | Responsibility | Depends on | Size (files / lines) |

## Data stores and external services
| Name | Kind | Configured in | Env vars | Used by |

## Configuration
| Variable | Read in | Default | Secret? |

## Where to start reading
1. `path` - why

## Risks noticed while mapping
- <e.g. no tests for billing/, secrets in config/prod.yml, two ORMs in use>

## Unknowns
- <questions only a human or production access can answer>
~~~

## Decision rules

- A fact needs a file path. No path, no fact; move it to Unknowns.
- Prefer CI config over README over your own inference.
- If the repo has more than one deployable (monorepo), map each deployable as a top-level
  node and give each its own commands table.
- If there are zero tests, say so in the first paragraph. It changes the whole plan.
- Generated code, vendored code and migrations are named once and then ignored.

## What NOT to do

- Do not run the application, its tests, migrations or install commands.
- Do not edit, format or "tidy" any file. The only files you write are under `rescue/`.
- Do not copy secret values into the map, the chat or any file.
- Do not invent architecture from folder names alone; open the files.
- Do not judge the code yet. Mapping is description; judgement comes with the plan.

## Hand-off

Next: run `rescue-hotspots` to find where the risk concentrates. If the map shows no test
suite at all, tell the user that `rescue-characterize` is the critical path before any change.
`rescue-plan` will read `rescue/map.md` later. For large repos you can delegate the reading to
the `legacy-cartographer` agent and review its draft.
Pliki w paczce (2)
  • SKILL.md 7 KB
  • inventory.py 15 KB

Wersje

W bazie nie ma innych skilli o nazwie rescue-map.

Migawka bazy z 13.11.2026 · wersja paczki 880c688429c0 (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

  • 100codebase-onboard
    Mapuje i wyjaśnia nieznany projekt JavaScript, TypeScript lub Python: architekturę, punkty wejścia, przepływ danych i miejsce zmiany.
  • 100codebase-onboarding
    Mapuje nieznane repozytorium przed zmianą: stos, polecenia, punkty wejścia, przepływ danych i sposób wdrażania zmian.
  • 100onboard-codebase
    Mapuje nieznane repozytorium na podstawie faktycznie przeczytanych plików: czym jest, punkty wejścia, uruchamianie, testy i ryzyka.
  • 100build-flow-map
    Opisuje, jak aplikacja się buduje i łączy: języki, komendy, zmienne, bazy, API i CI/CD, w pliku BUILD_FLOW.md.
  • 90repo-map-zoom-out
    Mapuje nieznany obszar kodu przed zmianą: punkty wejścia, granice, wywołania, przepływ danych i miejsca edycji.
  • 90repo-onboarding
    Szybko mapuje nieznane repozytorium: stos, punkty wejścia, wzorce i ryzyka, zanim powstaną zmiany w kodzie.

Uwagi i zgłoszenia

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