abap-mcp 0.2.0 → 0.3.1

package/README.md

@@ -6,8 +6,9 @@ an abapGit export, a code review, CI.
 
 Built on [abaplint](https://abaplint.org) (the open-source ABAP parser/linter) and the
 [Model Context Protocol](https://modelcontextprotocol.io). TypeScript, 100% local — the server
-makes **zero network calls** and touches **no filesystem**: sources go in as text, findings come
-back as structured JSON.
+makes **zero network calls** and reads **no user files**: sources go in as text, findings come
+back as structured JSON. (The released-API list and abaplint's rule data are package-bundled
+assets that ship inside the install — no network, no user filesystem, at runtime.)
 
 ## Why this exists
 
@@ -19,6 +20,7 @@ layer:
 
 - *"Does this ABAP parse? Is it clean?"* → `lint_abap`
 - *"How far is this classic report from ABAP Cloud?"* → `check_cloud_readiness`
+- *"Is MARA a released API? What do I use instead?"* → `check_released_api`
 - *"Start me a correct RAP business object."* → `scaffold_rap_bo`
 - *"What's in this 4,000-line class?"* → `get_abap_outline`
 
@@ -55,6 +57,7 @@ npx abap-mcp lint src/                          # lint files or whole directorie
 npx abap-mcp readiness src/ --fail-below 80     # repo-level ABAP Cloud readiness, CI-gateable
 npx abap-mcp scaffold --entity Travel --table ztravel --key travel_id --out ./out
 npx abap-mcp outline src/zcl_monster.clas.abap  # navigate big objects
+npx abap-mcp released MARA I_Product            # released-API status + CDS successor
 npx abap-mcp explain exit_or_check              # rule rationale
 ```
 
@@ -75,7 +78,8 @@ loop condition), per-repo `.mcp.json`, and a GitHub Actions quality gate for aba
 | Tool | What it does |
 | --- | --- |
 | `lint_abap` | abaplint static analysis over ABAP/CDS/BDEF sources → structured findings with rule docs links. Presets: `style` (default, snippet-friendly), `full`, `syntax-only`; per-rule overrides. |
-| `check_cloud_readiness` | Dual-parse diff (classic baseline vs `Cloud`): statements that are valid today but illegal in ABAP Cloud become categorized blockers (dynpro, list output, native SQL, …) with a transparent score; code broken at the baseline is reported separately, not counted as migration work. |
+| `check_cloud_readiness` | Dual-parse diff (classic baseline vs `Cloud`): statements that are valid today but illegal in ABAP Cloud become categorized blockers (dynpro, list output, native SQL, …) with a transparent score; code broken at the baseline is reported separately, not counted as migration work. Now also surfaces a **separate, dated released-API cross-check** (`releasedApiFindings`): direct access to non-released classic tables and deprecated-API usage found in the source, with CDS successor hints — informational, not folded into the score. |
+| `check_released_api` | Looks up objects (tables, CDS views, function modules, classes, …) in SAP's bundled Cloudification snapshot → `released` / `deprecated` / `not-released` per object, plus a curated CDS successor for common classic tables. The released-API half of readiness, offline. |
 | `scaffold_rap_bo` | Generates the canonical RAP managed-BO stack (root view, behavior definition `strict(2)` + optional draft, behavior class + handler locals, projection, metadata extension, OData V4 service definition) plus suggested table DDL, activation order and next steps. |
 | `list_abap_rules` | Browse abaplint's ~180 rules (filter by text or tag). |
 | `explain_abap_rule` | One rule in depth — rationale (often Clean ABAP), examples, docs URL. |
@@ -84,25 +88,29 @@ loop condition), per-repo `.mcp.json`, and a GitHub Actions quality gate for aba
 
 ## Honesty box — what this is *not*
 
-- **Not ATC.** Readiness here is *language-level*: statements ABAP Cloud removed. Whether your
-  code calls **released APIs only** requires a system's released-API list (ATC check
-  `SAP_CP_READINESS`) — out of scope for an offline tool, and the readiness report says so on
-  every call.
+- **Not ATC.** The objective readiness *score* is still language-level: statements ABAP Cloud
+  removed. Released-API coverage is now **partial and offline**: `check_released_api` and the
+  `releasedApiFindings` in readiness reflect SAP's published Cloudification list *as of the
+  bundled snapshot date* — they cover tables and function modules referenced in your source, not
+  every API, and are only as current as the snapshot. A target system's own released-API list
+  (ATC check `API_RELEASE_STATE_CHECK` / `SAP_CP_READINESS`) remains authoritative; treat an
+  "absent from the list" result as "not released as of the snapshot", not as proof.
 - **Scaffold validation is tiered.** Generated classes and CDS views are round-tripped through
   abaplint at Cloud level before they're returned (the generator and the linter share one
   parser). Behavior/service definitions are outside abaplint's checked surface — they are
   golden-tested canonical templates, and ADT activation is the final arbiter. Each generated
   file is labeled `validated: "abaplint" | "template"`.
-- **Text-in only, by design.** No filesystem walking, no network — the entire attack surface is
-  a parser over strings you explicitly pass. For linting whole directories, use the
-  [abaplint CLI](https://abaplint.org) in CI, or the
+- **Text-in only, by design.** No user-filesystem walking, no network — the entire attack
+  surface is a parser over strings you explicitly pass. (The released-API snapshot and abaplint's
+  rule data are package-bundled assets imported from the install, not fetched or read from your
+  disk.) For linting whole directories, use the [abaplint CLI](https://abaplint.org) in CI, or the
   [mcp-kit `wrap-abaplint` recipe](https://github.com/palimkarakshay/mcp-kit) this server grew out of.
 
 ## Develop
 
 ```bash
 npm install
-npm run check     # typecheck + 80 tests + build — the CI gate
+npm run check     # typecheck + 121 tests + build — the CI gate
 node dist/cli.js  # stdio MCP server
 npx @modelcontextprotocol/inspector --cli node dist/cli.js --method tools/list
 ```
@@ -110,7 +118,7 @@ npx @modelcontextprotocol/inspector --cli node dist/cli.js --method tools/list
 Tool descriptions are CI-graded (a rubric test enforces verb-first names, when-to-use,
 non-goals, described params, worked examples — the
 [mcp-kit](https://github.com/palimkarakshay/mcp-kit) discipline; the full mcp-kit lint scores all
-seven tools 100/100).
+eight tools 100/100).
 
 ## Design
 
@@ -122,6 +130,11 @@ scaffolder validates its own output, what was deliberately left out — lives in
 
 - [abaplint](https://github.com/abaplint/abaplint) by Lars Hvam — the parser and rule engine
   underneath every tool here (MIT).
+- [SAP/abap-atc-cr-cv-s4hc](https://github.com/SAP/abap-atc-cr-cv-s4hc) — SAP's official ABAP
+  Cloudification Repository (object release list), **Apache-2.0**. The bundled released-API
+  snapshot (`src/data/released-apis.json`, snapshot **2026-06-10**) is a compact transform of
+  that data, redistributed under Apache-2.0 with attribution; see
+  [docs/DESIGN.md](docs/DESIGN.md) and `scripts/build-released-api-index.mjs` for the pipeline.
 - [mcp-kit](https://github.com/palimkarakshay/mcp-kit) — the production-MCP patterns this server
   follows (typed tool specs, transport discipline, description lint).
 

package/dist/abap/engine.d.ts

@@ -44,3 +44,27 @@ export interface RunResult {
     fileCount: number;
 }
 export declare function runAbaplint(files: AbapSource[], opts: RunOptions): RunResult;
+/** A statically-resolved reference to a repository object found in the source. */
+export interface ObjectReference {
+    /** The referenced object name (upper-cased as written; tables are typically lowercased in source). */
+    name: string;
+    /** SAP object type: "TABL" for DB tables, "FUNC" for function modules. */
+    objectType: "TABL" | "FUNC";
+    /** How the reference appears, for the human-facing note. */
+    kind: "db-access" | "call-function";
+    file: string;
+    line: number;
+}
+/**
+ * Walk the parsed AST and collect references to repository objects we can
+ * resolve reliably: DB tables in ABAP-SQL statements (SELECT/INSERT/UPDATE/
+ * DELETE/MODIFY, including the tables in joins and FROM clauses) and function
+ * modules in CALL FUNCTION '<fm>'. Parsing is done at a classic baseline so the
+ * statements resolve even for code ABAP Cloud would reject; abaplint only
+ * parses, never executes. References are de-duplicated by name+type+location.
+ *
+ * Deliberately conservative: we extract only what the parser exposes as a
+ * first-class expression (DatabaseTable, FunctionName), not heuristic regexes,
+ * so a reference we report is a reference that exists.
+ */
+export declare function extractObjectReferences(files: AbapSource[], baselineVersion?: AbapVersion): ObjectReference[];

package/dist/abap/engine.js

@@ -141,3 +141,79 @@ export function runAbaplint(files, opts) {
     });
     return { findings, truncated: issues.length > MAX_FINDINGS, fileCount: bounded.length };
 }
+const SQL_STATEMENTS = new Set([
+    "Select",
+    "SelectLoop",
+    "InsertDatabase",
+    "UpdateDatabase",
+    "DeleteDatabase",
+    "ModifyDatabase",
+]);
+/**
+ * Walk the parsed AST and collect references to repository objects we can
+ * resolve reliably: DB tables in ABAP-SQL statements (SELECT/INSERT/UPDATE/
+ * DELETE/MODIFY, including the tables in joins and FROM clauses) and function
+ * modules in CALL FUNCTION '<fm>'. Parsing is done at a classic baseline so the
+ * statements resolve even for code ABAP Cloud would reject; abaplint only
+ * parses, never executes. References are de-duplicated by name+type+location.
+ *
+ * Deliberately conservative: we extract only what the parser exposes as a
+ * first-class expression (DatabaseTable, FunctionName), not heuristic regexes,
+ * so a reference we report is a reference that exists.
+ */
+export function extractObjectReferences(files, baselineVersion = "v758") {
+    const bounded = boundFiles(files);
+    const registry = new abaplint.Registry(buildConfig({ version: baselineVersion, preset: "syntax-only" }));
+    for (const f of bounded) {
+        registry.addFile(new abaplint.MemoryFile(f.filename, f.source));
+    }
+    registry.parse();
+    const refs = [];
+    const seen = new Set();
+    const push = (ref) => {
+        const dedupeKey = `${ref.objectType}:${ref.name}:${ref.file}:${ref.line}`;
+        if (seen.has(dedupeKey))
+            return;
+        seen.add(dedupeKey);
+        refs.push(ref);
+    };
+    for (const obj of registry.getObjects()) {
+        if (!(obj instanceof abaplint.ABAPObject))
+            continue;
+        for (const file of obj.getABAPFiles()) {
+            const filename = file.getFilename();
+            for (const st of file.getStatements()) {
+                const type = st.get().constructor.name;
+                if (SQL_STATEMENTS.has(type)) {
+                    for (const e of st.findAllExpressions(abaplint.Expressions.DatabaseTable)) {
+                        const name = e.concatTokens().trim();
+                        if (name.length === 0)
+                            continue;
+                        push({
+                            name: name.toUpperCase(),
+                            objectType: "TABL",
+                            kind: "db-access",
+                            file: filename,
+                            line: e.getFirstToken().getStart().getRow(),
+                        });
+                    }
+                }
+                else if (type === "CallFunction") {
+                    for (const e of st.findAllExpressions(abaplint.Expressions.FunctionName)) {
+                        const name = e.concatTokens().replace(/'/g, "").trim();
+                        if (name.length === 0)
+                            continue;
+                        push({
+                            name: name.toUpperCase(),
+                            objectType: "FUNC",
+                            kind: "call-function",
+                            file: filename,
+                            line: e.getFirstToken().getStart().getRow(),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return refs;
+}

package/dist/abap/readiness.d.ts

@@ -7,10 +7,12 @@
  * longer allows). A finding present at the baseline is just *broken code* —
  * reporting it as a migration item would overstate the migration.
  *
- * Honest scope: this is the static, parser-level slice of readiness. The
- * other half — "does this call only RELEASED SAP APIs?" — requires the
- * system's released-API list (ATC check SAP_CP_READINESS) and is out of
- * scope for an offline tool. The report says so.
+ * Released-API check: separately from the parser-level diff, the source is
+ * walked for object references (DB tables, function modules) which are looked
+ * up against the bundled SAP Cloudification snapshot. These land in their own
+ * `releasedApiFindings` field — they are NOT folded into cloudBlockerCount or
+ * score, because those are objective, parser-level numbers and the snapshot is
+ * only as current as its date.
  */
 import type { AbapSource, AbapVersion, Finding } from "./engine.js";
 export interface ReadinessCategory {
@@ -19,6 +21,25 @@ export interface ReadinessCategory {
     count: number;
     findings: Finding[];
 }
+/**
+ * A released-API observation about a referenced object. Kept SEPARATE from the
+ * parser-level blocker counts/score: it reflects the bundled SAP snapshot
+ * (dated), not abaplint's objective parse, and a system's ATC is authoritative.
+ */
+export interface ReleasedApiFinding {
+    /** Referenced object name (upper-cased). */
+    object: string;
+    /** SAP object type: "TABL" (DB table) or "FUNC" (function module). */
+    objectType: string;
+    /** Released-API state from the bundled snapshot. */
+    state: "deprecated" | "not-released";
+    /** Curated released CDS successor for a classic table, when known. */
+    successor?: string;
+    file: string;
+    line: number;
+    /** Human-facing explanation of why this was flagged. */
+    note: string;
+}
 export interface ReadinessReport {
     verdict: "ready" | "minor-rework" | "moderate-rework" | "significant-rework";
     score: number;
@@ -26,6 +47,14 @@ export interface ReadinessReport {
     categories: ReadinessCategory[];
     /** Findings that fail even at the classic baseline — fix these first; they are not migration items. */
     brokenAtBaseline: Finding[];
+    /**
+     * Released-API observations from the bundled SAP Cloudification snapshot —
+     * deprecated API usage and direct access to non-released (classic) tables,
+     * with successor hints. Separate from cloudBlockerCount/score by design.
+     */
+    releasedApiFindings: ReleasedApiFinding[];
+    /** Date of the bundled released-API snapshot the releasedApiFindings reflect. */
+    releasedApiSnapshotDate: string;
     baselineVersion: AbapVersion;
     scopeNote: string;
 }

package/dist/abap/readiness.js

@@ -1,6 +1,11 @@
-import { runAbaplint } from "./engine.js";
-export const SCOPE_NOTE = "Static parser-level analysis (abaplint). It detects statements and syntax that ABAP Cloud removes, " +
-    "but NOT usage of unreleased SAP APIs — that requires a system's released-API list (ATC / SAP_CP_READINESS). " +
+import { extractObjectReferences, runAbaplint } from "./engine.js";
+import { lookupReleased, RELEASED_API_SNAPSHOT, suggestSuccessor } from "./released.js";
+export const SCOPE_NOTE = "Static parser-level analysis (abaplint) PLUS a released-API cross-check against SAP's bundled Cloudification " +
+    `snapshot (dated ${RELEASED_API_SNAPSHOT.snapshotDate}). It detects statements ABAP Cloud removes (the objective ` +
+    "cloud-blocker count and score) and, separately, flags deprecated-API usage and direct access to non-released " +
+    "classic tables (releasedApiFindings — informational, NOT counted in the score). The bundled list is only as current " +
+    "as its snapshot date, and covers tables and function modules referenced here, not every API; a target system's own " +
+    "released-API list (ATC check API_RELEASE_STATE_CHECK / SAP_CP_READINESS) remains authoritative. " +
     "Treat 'ready' as 'no language-level blockers', not as a full Clean Core certification.";
 /** Map an offending line to a human category by its leading keyword(s). */
 function categorize(excerpt) {
@@ -50,7 +55,79 @@ export function checkCloudReadiness(files, baselineVersion = "v758") {
         cloudBlockerCount: n,
         categories: [...byCategory.values()].sort((a, b) => b.count - a.count),
         brokenAtBaseline: baseline.findings,
+        releasedApiFindings: computeReleasedApiFindings(files, baselineVersion),
+        releasedApiSnapshotDate: RELEASED_API_SNAPSHOT.snapshotDate,
         baselineVersion,
         scopeNote: SCOPE_NOTE,
     };
 }
+/**
+ * Cross-check statically-extracted object references against the bundled SAP
+ * Cloudification snapshot. Flags two cases:
+ *   - `deprecated` — the referenced object is a deprecated released API.
+ *   - `not-released` — the reference is explicitly recorded as notToBeReleased
+ *     in SAP's list: direct access to a classic/internal table (the typical
+ *     "SELECT … FROM mara" case, with a curated CDS successor hint when one is
+ *     known) or a CALL FUNCTION to an internal-only function module.
+ * Released objects and references the snapshot does not recognise are silent —
+ * absence from the list (every customer Z/Y-object, for a start) is "not known
+ * to be a problem", not proof either way.
+ */
+function computeReleasedApiFindings(files, baselineVersion) {
+    const out = [];
+    for (const ref of extractObjectReferences(files, baselineVersion)) {
+        let hit = lookupReleased(ref.name, ref.objectType);
+        // An ABAP-SQL FROM clause names either a DDIC table or a CDS entity, but
+        // the extractor labels both TABL — fall back to the CDS record so a
+        // deprecated CDS view in a SELECT is still caught.
+        if (!hit.recorded && ref.objectType === "TABL") {
+            hit = lookupReleased(ref.name, "CDS_STOB");
+        }
+        if (hit.state === "released")
+            continue;
+        if (hit.state === "deprecated") {
+            out.push({
+                object: ref.name,
+                objectType: ref.objectType,
+                state: "deprecated",
+                file: ref.file,
+                line: ref.line,
+                note: ref.kind === "db-access"
+                    ? `${ref.name} is a deprecated released object as of the snapshot — migrate to its current successor before going to ABAP Cloud.`
+                    : `Function module ${ref.name} is deprecated as of the snapshot — replace it with the released successor API.`,
+            });
+            continue;
+        }
+        // not-released. Only flag names SAP's snapshot explicitly records as
+        // notToBeReleased — a name merely absent from the list (every customer
+        // Z/Y-object, for a start) is silent: absence is "not known to be a
+        // problem", not evidence of one.
+        if (!hit.recorded)
+            continue;
+        if (ref.objectType === "FUNC") {
+            out.push({
+                object: ref.name,
+                objectType: ref.objectType,
+                state: "not-released",
+                file: ref.file,
+                line: ref.line,
+                note: `Function module ${ref.name} is recorded as not-to-be-released in SAP's Cloudification list — it will not become a public API in ABAP Cloud; use a released successor API instead.`,
+            });
+            continue;
+        }
+        if (ref.objectType === "TABL" && hit.objectType === "TABL") {
+            const successor = suggestSuccessor(ref.name);
+            out.push({
+                object: ref.name,
+                objectType: ref.objectType,
+                state: "not-released",
+                ...(successor !== undefined ? { successor } : {}),
+                file: ref.file,
+                line: ref.line,
+                note: `${ref.name} is not a released API — direct access to this classic table is not allowed in ABAP Cloud.` +
+                    (successor !== undefined ? ` Use the released CDS view ${successor} instead.` : " Use a released CDS view instead."),
+            });
+        }
+    }
+    return out;
+}

package/dist/abap/released.d.ts

@@ -0,0 +1,46 @@
+/** Snapshot metadata for the bundled released-API list. */
+export declare const RELEASED_API_SNAPSHOT: {
+    readonly snapshotDate: string;
+    readonly source: string;
+    readonly formatVersion: string | null;
+    readonly recordCount: number;
+};
+export type ReleasedState = "released" | "deprecated" | "not-released";
+export interface ReleasedLookup {
+    name: string;
+    /** The object type recorded by SAP (TABL, CDS_STOB, FUNC, CLAS, …), or the queried type when no record matched. */
+    objectType: string | undefined;
+    state: ReleasedState;
+    applicationComponent?: string | undefined;
+    /**
+     * true when the name was found in SAP's snapshot (under the requested type,
+     * if one was given). false means absent — "not released as of the snapshot"
+     * by omission, which is weaker evidence than an explicit notToBeReleased
+     * record and must not be reported as a violation on its own.
+     */
+    recorded: boolean;
+}
+/**
+ * Look up an object in the bundled released-API list. Case-insensitive.
+ *
+ * `not-released` means "not a released API as of the snapshot": either the name
+ * is absent from SAP's list, or it is present with state `notToBeReleased`
+ * (typical for classic DDIC tables). A `released`/`deprecated` result is taken
+ * verbatim from SAP's published data.
+ *
+ * When `objectType` is given the lookup is strict: only a record of exactly
+ * that type answers the query — a same-named record under a different type is
+ * a miss (`recorded: false`), never a substitute (a released class must not
+ * make a non-released table look released). Untyped lookups use the first
+ * recorded entry, preferring a `released` or `deprecated` record over a
+ * `notToBeReleased` one so a genuinely released API is never masked by a
+ * same-named internal object.
+ */
+export declare function lookupReleased(objectName: string, objectType?: string): ReleasedLookup;
+/**
+ * Suggest the canonical released CDS view-entity successor for a classic DB
+ * table, from the curated table-successors map. Case-insensitive. Returns
+ * undefined when no curated successor is known (the caller should fall back to
+ * the target system's released-API list).
+ */
+export declare function suggestSuccessor(tableName: string): string | undefined;

package/dist/abap/released.js

@@ -0,0 +1,94 @@
+/**
+ * Released-API lookup against SAP's published ABAP Cloudification list.
+ *
+ * The data shipped at src/data/released-apis.json is a compact transform of
+ * SAP's official, Apache-2.0 object release list (SAP/abap-atc-cr-cv-s4hc),
+ * built offline by scripts/build-released-api-index.mjs. It is a PACKAGE-BUNDLED
+ * asset (like abaplint's own bundled rule metadata): importing it touches no
+ * network and no user filesystem at runtime, so it does not violate the
+ * server's "text in, JSON out, offline" contract.
+ *
+ * SAP's list uses three states:
+ *   - "released"        — a released API, safe to consume in ABAP Cloud.
+ *   - "deprecated"      — was released, now on the way out; move to a successor.
+ *   - "notToBeReleased" — will not be released as a public API (classic DDIC
+ *                         tables, internal objects); direct use is a cloud
+ *                         blocker. We surface these (and names absent from the
+ *                         list entirely) as state "not-released".
+ */
+import index from "../data/released-apis.json" with { type: "json" };
+import successorData from "../data/table-successors.json" with { type: "json" };
+const data = index;
+const successors = successorData;
+/** Snapshot metadata for the bundled released-API list. */
+export const RELEASED_API_SNAPSHOT = {
+    snapshotDate: data.snapshotDate,
+    source: data.source,
+    formatVersion: data.formatVersion,
+    recordCount: data.recordCount,
+};
+/** Map SAP's raw state to our three-value state. */
+function toState(rawState) {
+    if (rawState === "released")
+        return "released";
+    if (rawState === "deprecated")
+        return "deprecated";
+    // "notToBeReleased" — present in the list but never a public API.
+    return "not-released";
+}
+/**
+ * Look up an object in the bundled released-API list. Case-insensitive.
+ *
+ * `not-released` means "not a released API as of the snapshot": either the name
+ * is absent from SAP's list, or it is present with state `notToBeReleased`
+ * (typical for classic DDIC tables). A `released`/`deprecated` result is taken
+ * verbatim from SAP's published data.
+ *
+ * When `objectType` is given the lookup is strict: only a record of exactly
+ * that type answers the query — a same-named record under a different type is
+ * a miss (`recorded: false`), never a substitute (a released class must not
+ * make a non-released table look released). Untyped lookups use the first
+ * recorded entry, preferring a `released` or `deprecated` record over a
+ * `notToBeReleased` one so a genuinely released API is never masked by a
+ * same-named internal object.
+ */
+export function lookupReleased(objectName, objectType) {
+    const key = objectName.trim().toUpperCase();
+    const entries = data.objects[key];
+    const wantedType = objectType?.trim().toUpperCase();
+    if (entries === undefined || entries.length === 0) {
+        return { name: objectName, objectType: wantedType, state: "not-released", recorded: false };
+    }
+    let chosen;
+    if (wantedType !== undefined) {
+        chosen = entries.find((e) => e[0].toUpperCase() === wantedType);
+        if (chosen === undefined) {
+            // Typed query, no record of that type: a miss, not a cross-type answer.
+            return { name: objectName, objectType: wantedType, state: "not-released", recorded: false };
+        }
+    }
+    else {
+        // Prefer a released/deprecated record over notToBeReleased when ambiguous.
+        chosen =
+            entries.find((e) => e[1] === "released" || e[1] === "deprecated") ?? entries[0];
+    }
+    if (chosen === undefined) {
+        return { name: objectName, objectType: wantedType, state: "not-released", recorded: false };
+    }
+    return {
+        name: objectName,
+        objectType: chosen[0],
+        state: toState(chosen[1]),
+        applicationComponent: chosen[2],
+        recorded: true,
+    };
+}
+/**
+ * Suggest the canonical released CDS view-entity successor for a classic DB
+ * table, from the curated table-successors map. Case-insensitive. Returns
+ * undefined when no curated successor is known (the caller should fall back to
+ * the target system's released-API list).
+ */
+export function suggestSuccessor(tableName) {
+    return successors.successors[tableName.trim().toUpperCase()];
+}

package/dist/abap.tools.d.ts

@@ -82,6 +82,12 @@ export declare const getAbapOutline: import("./tool.js").ToolSpec<{
         source: z.ZodString;
     }, z.core.$strip>>;
 }>;
+export declare const checkReleasedApiTool: import("./tool.js").ToolSpec<{
+    objects: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+}>;
 /** Every tool this server exposes. (`tools` alias = the registry-export shape @mcp-kit/lint discovers.) */
 export declare const ALL_TOOLS: readonly AnyToolSpec[];
 export declare const tools: readonly AnyToolSpec[];