abap-mcp 0.1.1 → 0.3.0

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`
 
@@ -46,12 +48,38 @@ claude mcp add abap-mcp -- node /path/to/abap-mcp/dist/cli.js
 Then ask your agent things like *"lint this class against ABAP Cloud"*, *"is zold_report
 cloud-ready?"*, or *"scaffold a RAP BO for entity Booking on table zbooking, draft enabled"*.
 
+## CLI — same engine, no AI required
+
+Every tool is also a subcommand, so it works in terminals and CI where no MCP client exists:
+
+```bash
+npx abap-mcp lint src/                          # lint files or whole directories
+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
+```
+
+Directories are walked recursively (abapGit naming), batched automatically, and `readiness`
+merges batches into one scored, categorized repo report. Exit codes are CI-friendly
+(`1` on error findings / failed threshold).
+
+## Recipes, agents & CI
+
+**[docs/COOKBOOK.md](docs/COOKBOOK.md)** — practical recipes: the fix-until-clean loop,
+PR review without a transport, whole-repo migration triage, CI gates, per-persona use cases.
+**[examples/claude-code/](examples/claude-code/)** — drop-in agentic workflows: an
+`abap-code-reviewer` subagent, an `abap-cloud-migrator` sweep loop (readiness score as the
+loop condition), per-repo `.mcp.json`, and a GitHub Actions quality gate for abapGit repos.
+
 ## Tools
 
 | 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. |
@@ -60,25 +88,29 @@ cloud-ready?"*, or *"scaffold a RAP BO for entity Booking on table zbooking, dra
 
 ## 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 + 115 tests + build — the CI gate
 node dist/cli.js  # stdio MCP server
 npx @modelcontextprotocol/inspector --cli node dist/cli.js --method tools/list
 ```
@@ -86,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
 
@@ -98,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,57 @@ 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` — direct access to a classic/internal table that is not a
+ *     released API (the typical "SELECT … FROM mara" case), with a curated CDS
+ *     successor hint when one is known.
+ * Released objects and references the snapshot does not recognise are silent —
+ * absence from the list is "not known to be a problem", not proof either way.
+ */
+function computeReleasedApiFindings(files, baselineVersion) {
+    const out = [];
+    for (const ref of extractObjectReferences(files, baselineVersion)) {
+        const hit = lookupReleased(ref.name, ref.objectType);
+        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 DB tables (direct table access is the cloud
+        // anti-pattern); a CALL FUNCTION to a module simply absent from the list is
+        // too noisy to report as a finding without a system to confirm against.
+        if (ref.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,36 @@
+/** 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;
+}
+/**
+ * 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 it disambiguates the few hundred names that exist
+ * under more than one object type; otherwise the first recorded entry is used,
+ * 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,86 @@
+/**
+ * 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 it disambiguates the few hundred names that exist
+ * under more than one object type; otherwise the first recorded entry is used,
+ * 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];
+    if (entries === undefined || entries.length === 0) {
+        return { name: objectName, objectType, state: "not-released" };
+    }
+    const wantedType = objectType?.trim().toUpperCase();
+    let chosen;
+    if (wantedType !== undefined) {
+        chosen = entries.find((e) => e[0].toUpperCase() === wantedType);
+    }
+    if (chosen === undefined) {
+        // 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, state: "not-released" };
+    }
+    return {
+        name: objectName,
+        objectType: chosen[0],
+        state: toState(chosen[1]),
+        applicationComponent: chosen[2],
+    };
+}
+/**
+ * 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[];

package/dist/abap.tools.js

@@ -11,6 +11,7 @@ import { ABAP_VERSIONS, runAbaplint } from "./abap/engine.js";
 import { formatAbap } from "./abap/formatter.js";
 import { outlineAbap } from "./abap/outline.js";
 import { checkCloudReadiness } from "./abap/readiness.js";
+import { lookupReleased, RELEASED_API_SNAPSHOT, suggestSuccessor, } from "./abap/released.js";
 import { explainRule, listRules } from "./abap/rules.js";
 import { scaffoldRapBo } from "./abap/scaffold.js";
 import { invalidInput } from "./errors.js";
@@ -132,6 +133,12 @@ export const checkCloudReadinessTool = defineTool({
         brokenAtBaseline: z
             .array(z.unknown())
             .describe("Findings that fail even at the baseline version — fix first, they are not migration items."),
+        releasedApiFindings: z
+            .array(z.unknown())
+            .describe("Released-API observations from the bundled SAP Cloudification snapshot (deprecated-API usage, direct non-released table access with successor hints). Informational — NOT counted in cloudBlockerCount or score."),
+        releasedApiSnapshotDate: z
+            .string()
+            .describe("Date of the bundled released-API snapshot the releasedApiFindings reflect."),
         baselineVersion: z.string().describe("The baseline used."),
         scopeNote: z.string().describe("Exactly what this check does and does not cover."),
     },
@@ -151,6 +158,9 @@ export const checkCloudReadinessTool = defineTool({
             (catLine.length > 0 ? ` [${catLine}]` : "") +
             (report.brokenAtBaseline.length > 0
                 ? `; ${report.brokenAtBaseline.length} finding(s) broken at ${report.baselineVersion} regardless`
+                : "") +
+            (report.releasedApiFindings.length > 0
+                ? `; ${report.releasedApiFindings.length} released-API note(s) (snapshot ${report.releasedApiSnapshotDate})`
                 : "");
         return {
             content: [{ type: "text", text }],
@@ -417,11 +427,109 @@ export const getAbapOutline = defineTool({
         };
     },
 });
+/** Accept either a bare name string or a { name, type? } reference. */
+const objectRefField = z
+    .array(z.union([
+    z.string().describe('A bare object name, e.g. "MARA" or "I_Product".'),
+    z.object({
+        name: z.string().describe('Object name, e.g. "MARA", "I_Product", "BAPI_MATERIAL_GET_DETAIL".'),
+        type: z
+            .string()
+            .optional()
+            .describe('Optional SAP object type to disambiguate same-named objects: "TABL" (table), "CDS_STOB" (CDS view entity), "FUNC" (function module), "CLAS", "INTF", "BDEF". Omit if unsure.'),
+    }),
+]))
+    .min(1)
+    .max(200)
+    .describe('Objects to check, 1–200 per call. Each is a bare name string or a { name, type? } object, e.g. ["MARA", { "name": "I_Product", "type": "CDS_STOB" }].');
+export const checkReleasedApiTool = defineTool({
+    name: "check_released_api",
+    title: "Check ABAP released-API status",
+    description: "Look up ABAP repository objects (DB tables, CDS view entities, function modules, classes, interfaces, …) in " +
+        "SAP's published ABAP Cloudification list and report, per object, whether it is a 'released' API (safe to use in " +
+        "ABAP Cloud / Clean Core), 'deprecated' (released but being retired), or 'not-released' (a classic/internal object " +
+        "that is not a public API — e.g. most classic DDIC tables) — with a curated CDS successor hint for common tables. " +
+        `This reflects SAP's official Cloudification list as bundled in this package (snapshot ${RELEASED_API_SNAPSHOT.snapshotDate}); ` +
+        "it ships offline with the server. " +
+        "Use this when you need to know if your code may reference a given object in ABAP Cloud, or which released CDS view " +
+        "to use instead of a classic table — the released-API half of readiness that check_cloud_readiness deliberately " +
+        "leaves to a system's ATC. " +
+        "It does not connect to any SAP system, does not run ATC, and is only as current as the bundled snapshot — a " +
+        `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. " +
+        'Example: check_released_api({ "objects": ["MARA", "I_Product", "BAPI_MATERIAL_GET_DETAIL"] }).',
+    inputSchema: {
+        objects: objectRefField,
+    },
+    outputSchema: {
+        snapshotDate: z.string().describe("Date of the bundled SAP Cloudification snapshot these results reflect."),
+        source: z.string().describe("URL of the SAP Apache-2.0 source the snapshot was built from."),
+        results: z.array(z.object({
+            name: z.string().describe("The object name as queried."),
+            objectType: z
+                .string()
+                .optional()
+                .describe("SAP object type of the matched record (TABL, CDS_STOB, FUNC, …), if found."),
+            state: z
+                .enum(["released", "deprecated", "not-released"])
+                .describe("'released' = safe public API; 'deprecated' = retiring; 'not-released' = not a public API."),
+            applicationComponent: z
+                .string()
+                .optional()
+                .describe("Owning application component of the matched record, if found."),
+            successor: z
+                .string()
+                .optional()
+                .describe("Curated released CDS view-entity successor for a classic table, when one is known."),
+        })),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false, idempotentHint: true },
+    examples: [
+        {
+            description: "Check a classic table, a released CDS view, and a BAPI in one call.",
+            arguments: { objects: ["MARA", "I_Product", "BAPI_MATERIAL_GET_DETAIL"] },
+        },
+        {
+            description: "Disambiguate a name that exists under more than one object type.",
+            arguments: { objects: [{ name: "I_ProcurementProjectTP", type: "CDS_STOB" }] },
+        },
+    ],
+    handler: (args) => {
+        const results = args.objects.map((ref) => {
+            const name = typeof ref === "string" ? ref : ref.name;
+            const type = typeof ref === "string" ? undefined : ref.type;
+            const hit = lookupReleased(name, type);
+            const successor = suggestSuccessor(name);
+            return {
+                name: hit.name,
+                objectType: hit.objectType,
+                state: hit.state,
+                applicationComponent: hit.applicationComponent,
+                ...(successor !== undefined ? { successor } : {}),
+            };
+        });
+        const text = results
+            .map((r) => {
+            const tail = r.successor !== undefined ? ` → use ${r.successor}` : "";
+            return `${r.name}: ${r.state}${r.objectType !== undefined ? ` (${r.objectType})` : ""}${tail}`;
+        })
+            .join("\n");
+        return {
+            content: [{ type: "text", text: `Snapshot ${RELEASED_API_SNAPSHOT.snapshotDate}\n${text}` }],
+            structuredContent: {
+                snapshotDate: RELEASED_API_SNAPSHOT.snapshotDate,
+                source: RELEASED_API_SNAPSHOT.source,
+                results,
+            },
+        };
+    },
+});
 /** Every tool this server exposes. (`tools` alias = the registry-export shape @mcp-kit/lint discovers.) */
 export const ALL_TOOLS = [
     lintAbap,
     checkCloudReadinessTool,
     scaffoldRapBoTool,
+    checkReleasedApiTool,
     listAbapRules,
     explainAbapRule,
     formatAbapTool,