Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

abapsmith-explore-a-package

/abapsmith-explore-a-package

Mapuje nieznany pakiet lub obiekt ABAP: co zawiera, co kogo wywołuje i co się zmieniło, przy użyciu narzędzi abap_search i abap_read.

Repozytorium
abapsmith ↗
Licencja
MIT
Ostatnia zmiana repozytorium
17.10.2026

Ocena i bezpieczeństwo

90/ 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ść25 / 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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 17.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

Mapuje nieznany pakiet lub obiekt ABAP: co zawiera, co kogo wywołuje i co się zmieniło, przy użyciu narzędzi abap_search i abap_read.

Oryginalny opis (EN)

Maps an unfamiliar ABAP package or object with abap_search and abap_read — what is in it, what calls what, and what changed. Use when asked to survey, understand, or find your way around code you did not write.

Jak działa

  1. When a task names a package, orient from it first
  2. The pipeline
  3. Live transcript (A4H, 2026-09-12)
  4. Refusals and limits
  5. How to prove it
  6. Not this skill
Sekcje z nagłówków SKILL.md, w oryginale · 133 linii, 1 175 słów
Podgląd SKILL.md
---
name: abapsmith-explore-a-package
description: Maps an unfamiliar ABAP package or object with abap_search and abap_read — what is in it, what calls what, and what changed. Use when asked to survey, understand, or find your way around code you did not write.
---

# Exploring a package

Read-only. Nothing here writes to the system — this is `abap_search` and
`abap_read` only, chained in the order below.

## When a task names a package, orient from it first

`abap_read {"object":"<PKG>","type":"DEVC/K"}` before searching or guessing
object names. It returns the package header plus its contents: a per-type
object count, direct sub-packages, and the object rows themselves. Narrow a
large package with `types` (e.g. `{"types":["CLAS","DDLS"]}`); go deeper
with `depth` (1-3, default 1) to include sub-packages. Then read individual
objects normally: `abap_read {"object":"<name>","type":"<type>"}` — rows
carry no `PARENT_NAME`, so nothing needs parenting to open. See
`doc/TOOLS/read-and-search.md`.

## The pipeline

1. `abap_search mode="objects"` — find the package by name pattern.
2. `abap_read` the package itself, `type: "DEVC/K"` — lists its direct contents.
3. `abap_read` a class of interest — above 150 lines / 8000 chars the answer
   is its outline (component list) by default; `outline: true` asks for it
   on a small class, `full: true` for the whole source of a large one.
4. `abap_read` one method by name — `method:` — instead of the whole class.
5. `abap_search mode="where_used"` — who calls this object.
6. `abap_read view="history"` / `view="diff"` — what changed and when.

## Live transcript (A4H, 2026-09-12)

Everything in this section was observed against reference system A4H on that
date. Numbers, note text and behaviour below are what the server actually sent.

**a. A broad sweep discloses its own cost.**
`abap_search { "query": "Z*", "type": "DEVC", "max": 30 }` returned 6 customer
packages, plus `serverHits: 300`, `droppedByTypeFilter: 294`, `fetchMax: 300`,
an `UNDER-REPORTED` note, and a `--- TRUNCATED ---` marker. `max` bounds what is
**shown**, not what is **fetched** — the server's own type filter is not
trusted, so filtering happens client-side after a wide untyped fetch.
**Narrowing the query — not lowering `max` — is what makes a call cheaper.** A
broad `Z*` sweep costs the same whatever `max` you pass.

**b. Reading a package works, and it is the fastest way to see what is in one.**
`abap_read { "object": "$TMP", "type": "DEVC/K" }` returned the package's
direct ADT node contents: `objects: 391`, `subPackages: 1`, `mode: ddic`, an
etag, an "OBJECTS BY TYPE" count table (`CLAS/OC 5`, `PROG/P 3`, `TABL/DT 1`,
…), then a name/description listing. Two notes came with it: "a package is
not a DDIC object: this is its direct node contents, not pseudo-DDL", and "1
sub-package(s) are listed but NOT expanded — their contents are not included
here. Read each sub-package to see them." A package read is **one level
deep**; recurse by hand for sub-packages. A separate read of a real customer
package returned `objects: 0` with the note "the ADT node structure returned
no objects. This is what the server sent, not a rendering failure." — an
empty package listing is an answer, not a failure.

**c. Observed defect worth a warning.** In that `$TMP` listing the
`description` column was misaligned against the `name` column by one row:
`ZCL_I72_RUNNER` printed carrying the description "Class ZCL_I72_PROBE",
`ZCL_I72_SCAN` carrying "Class ZCL_I72_RUNNER", and so on down the block. This
was an observed, reproducible-looking shift on A4H on that date — not a
proven general defect. The practical rule: **do not trust the description
column of a listing to belong to the row it is printed beside** — confirm by
reading the object. `abap_search` carries its own explicit `DESCRIPTIONS MAY
BE MIS-PAIRED` warning for the same class of problem (see
`src/tools/search.ts`), so this is a known hazard in listings generally, not
a one-off.

**d. Outline row count and component count are different numbers.**
`abap_read { "object": "CL_ADT_REST_RESOURCE", "type": "CLAS/OC", "outline": true }`
returned `components: 39` but an outline of only **8** rows, each
`NAME [public|protected|private instance] lines N-M`. The component count and
the outline row count mean different things — the outline lists what is
implemented, with its line ranges. Use those line ranges, or `method:`, to
read one method instead of the whole class.

**e. Where-used on a wide target is slow, and can still come back empty.**
`abap_search { "mode": "where_used", "query": "ZIF_APACK_MANIFEST", "max": 10 }`
took **19.2 seconds to return zero references**. The response said so itself:
"ADT's usageReferences endpoint has no server-side limit, so the entire set is
enumerated and transferred before `max` is applied. The cost is set by the
target's fan-in, not by `max` — lowering `max` would not have made this call
cheaper." Budget for that: a where-used on a widely-referenced object is a
slow call, and a fast way to get nothing is to ask about a narrower object.
Where-used is also **static**: dynamic calls (`CALL FUNCTION lv_name`,
`PERFORM (lv_form)`, `SUBMIT (lv_prog)`) do not appear, and those are blind
spots, not absences.

**f. A `$TMP` object can have no history at all.**
`abap_read { "object": "ZCL_I92_PROBE", "type": "CLAS/OC", "view": "history" }`
on a `$TMP` class written and activated three times returned `versions: 1`,
`released: 0`. SAP writes a version row **on transport release or upgrade
import, never on local activation**, so a `$TMP` / local object accumulates no
history no matter how often it is edited. `00000` is the ACTIVE pseudo-version
and serves the object's *current* source rather than a snapshot; `99999` is
INACTIVE. **Neither is history**, and with no predecessor there is nothing for
`view: "diff"` to compare against. Also: ADT versions each class **include**
separately, so a change made in `testclasses` does not appear in `main`'s
history — re-run with the `include` you care about. The raw feed is also
noisy and unsorted (one captured A4H feed returned 68 entries, of which about
60 were the same ACTIVE row); the tool de-duplicates by version number and
sorts newest-first, so what you see is already cleaned up. An empty
transport/author/date column is the feed's own silence, not a lookup failure.

## Refusals and limits

- Responses are capped and **truncation is always marked** — a
  `--- TRUNCATED ---` marker or a `response:` line with `truncated`/`hasMore`
  means you are looking at part of the answer. Never treat a truncated list as
  complete.
- `include: "testclasses"` is how you see a class's unit tests; they are not
  in `main`.
- An `etag` from a read is what you pass as a later write's `expect_etag`,
  which is how you find out someone else changed the object underneath you.
- `view: "diff"` needs a `from`/`to` and something to compare — see (f) above
  for the case where there is nothing to diff against at all.
- Reads are unaffected by `ABAP_MODE`; this whole skill works on a read-only
  server.

## How to prove it

A survey is proven by naming objects and line ranges you actually read back,
not by a plausible summary. When a listing and a read disagree — as the
misaligned description column above shows they can — the read of the object
wins.

## Not this skill

Creating anything is `abapsmith-create-an-object` (or `abapsmith-orient` to
check what abapsmith can build first). Customizing structure (SPRO) is
`abapsmith-browse-img-customizing`. Table rows need `abap_data_preview`,
which is off by default — gating is independent of `ABAP_MODE` and, once
on, it is allowed even under `read`.

Wersje

W bazie nie ma innych skilli o nazwie abapsmith-explore-a-package.

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

  • 100abapsmith-write-abap-unit-tests
    Pisze i uruchamia testy ABAP Unit dla klasy przez abap_write, abap_activate i abap_test oraz odczytuje pokrycie.
  • 100abapsmith-run-tests-and-fix
    Uruchamia ABAP Unit przez abap_test i zamienia nieudany test w poprawkę.
  • 100documentation
    Pisze dokumentację obiektu lub pakietu SAP ABAP na podstawie kodu: cel, wejścia, wyjścia, tabele, wywołania i ryzyka, w formacie Markdown.
  • 90explore
    Pomaga zrozumieć nieznany lub szeroki fragment lokalnego kodu przed planowaniem i zmianami.
  • 100clean-abap
    Pisze i przegląda kod ABAP zgodnie z przewodnikiem Clean ABAP: klasy, moduły funkcji, programy, interfejsy i transporty.
  • 100clean-abap
    Prowadzi styl i utrzymywalność kodu Clean ABAP: nazewnictwo, strukturę, nowoczesną składnię, formatowanie, komentarze i refaktoryzację podczas pisania ABAP lub przeglądu pod kątem stylu.

Uwagi i zgłoszenia

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