abap-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akshay Palimkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# abap-mcp
+
+**MCP server for SAP ABAP — offline static analysis, ABAP Cloud readiness, and RAP scaffolding.**
+No SAP system. No credentials. Works on ABAP source wherever your AI agent works: a git checkout,
+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.
+
+## Why this exists
+
+Every other ABAP MCP server is either a **bridge to a live SAP system** (ADT/RFC — needs
+credentials, a system, and trust) or a **documentation search**. But AI coding agents spend most
+of their time where the *files* are — editing abapGit repos, reviewing diffs, generating code —
+long before anything reaches a system. This server gives agents the missing feedback loop at that
+layer:
+
+- *"Does this ABAP parse? Is it clean?"* → `lint_abap`
+- *"How far is this classic report from ABAP Cloud?"* → `check_cloud_readiness`
+- *"Start me a correct RAP business object."* → `scaffold_rap_bo`
+- *"What's in this 4,000-line class?"* → `get_abap_outline`
+
+## Quickstart
+
+```bash
+# Claude Code
+claude mcp add abap-mcp -- npx -y abap-mcp
+
+# or any MCP client (.mcp.json / mcp.json):
+{
+  "mcpServers": {
+    "abap-mcp": { "command": "npx", "args": ["-y", "abap-mcp"] }
+  }
+}
+```
+
+From a clone instead:
+
+```bash
+npm install && npm run build
+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"*.
+
+## 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. |
+| `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. |
+| `format_abap` | Offline pretty-printer (keyword case + indentation). |
+| `get_abap_outline` | Classes/methods/visibility/interfaces/FORMs of a source — navigate big objects without reading them whole. |
+
+## 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.
+- **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
+  [mcp-kit `wrap-abaplint` recipe](https://github.com/lumivarahq/mcp-kit) this server grew out of.
+
+## Develop
+
+```bash
+npm install
+npm run check     # typecheck + 80 tests + build — the CI gate
+node dist/cli.js  # stdio MCP server
+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/lumivarahq/mcp-kit) discipline; the full mcp-kit lint scores all
+seven tools 100/100).
+
+## Design
+
+The decision log — why offline, why abaplint, why a dual-parse readiness diff, why the
+scaffolder validates its own output, what was deliberately left out — lives in
+[`docs/DESIGN.md`](docs/DESIGN.md).
+
+## Credits
+
+- [abaplint](https://github.com/abaplint/abaplint) by Lars Hvam — the parser and rule engine
+  underneath every tool here (MIT).
+- [mcp-kit](https://github.com/lumivarahq/mcp-kit) — the production-MCP patterns this server
+  follows (typed tool specs, transport discipline, description lint).
+
+MIT © Akshay Palimkar. Not affiliated with or endorsed by SAP SE. "SAP", "ABAP" and "RAP" are
+trademarks of SAP SE; this is an independent open-source tool for developers working with them.

package/dist/abap/engine.d.ts

@@ -0,0 +1,46 @@
+export interface AbapSource {
+    filename?: string | undefined;
+    source: string;
+}
+export interface Finding {
+    rule: string;
+    message: string;
+    severity: string;
+    file: string;
+    line: number;
+    column: number;
+    /** First ~100 chars of the offending line, for fix-it-without-reopening flows. */
+    excerpt: string;
+    docsUrl: string;
+}
+export declare const MAX_FILES = 32;
+export declare const MAX_FILE_CHARS = 100000;
+export declare const MAX_FINDINGS = 500;
+/** ABAP language versions a caller may target. */
+export declare const ABAP_VERSIONS: readonly ["Cloud", "v750", "v751", "v752", "v753", "v754", "v755", "v756", "v757", "v758"];
+export type AbapVersion = (typeof ABAP_VERSIONS)[number];
+/**
+ * Infer an abapGit-conventional filename from the source's first meaningful
+ * statement, so agents can lint snippets without knowing the convention.
+ */
+export declare function inferFilename(source: string, given?: string): string;
+export interface RunOptions {
+    version: AbapVersion;
+    /** abaplint rule config; merged over the preset. */
+    rules?: Record<string, unknown> | undefined;
+    /**
+     * "style"       — abaplint's default ruleset minus whole-program semantic
+     *                 checks, so isolated snippets don't drown in noise about
+     *                 objects that simply weren't provided.
+     * "full"        — abaplint's default ruleset as-is (expects you to provide
+     *                 every referenced dev object).
+     * "syntax-only" — parser + CDS parser errors only.
+     */
+    preset: "style" | "full" | "syntax-only";
+}
+export interface RunResult {
+    findings: Finding[];
+    truncated: boolean;
+    fileCount: number;
+}
+export declare function runAbaplint(files: AbapSource[], opts: RunOptions): RunResult;

package/dist/abap/engine.js

@@ -0,0 +1,143 @@
+/**
+ * The abaplint engine wrapper.
+ *
+ * Design rules:
+ *  - A fresh in-memory Registry per call — no shared state, safe under
+ *    concurrent tool calls (pattern proven in RAP Dojo's /api/lint-abap).
+ *  - abaplint PARSES the input, it never executes it. Inputs are still
+ *    bounded (file count / chars) to keep each call cheap.
+ *  - Filenames drive abaplint's object typing (zcl_x.clas.abap = a class).
+ *    Callers may omit them; we infer from the source's leading statement.
+ */
+import * as abaplint from "@abaplint/core";
+export const MAX_FILES = 32;
+export const MAX_FILE_CHARS = 100_000;
+export const MAX_FINDINGS = 500;
+/** ABAP language versions a caller may target. */
+export const ABAP_VERSIONS = [
+    "Cloud",
+    "v750",
+    "v751",
+    "v752",
+    "v753",
+    "v754",
+    "v755",
+    "v756",
+    "v757",
+    "v758",
+];
+const FILENAME_RE = /^[a-zA-Z0-9_#-]+\.(clas\.abap|clas\.locals_imp\.abap|clas\.locals_def\.abap|clas\.testclasses\.abap|prog\.abap|intf\.abap|fugr\.abap|ddls\.asddls|bdef\.asbdef|srvd\.srvdsrv|ddlx\.asddlx)$/;
+/**
+ * Infer an abapGit-conventional filename from the source's first meaningful
+ * statement, so agents can lint snippets without knowing the convention.
+ */
+export function inferFilename(source, given) {
+    if (given !== undefined) {
+        if (!FILENAME_RE.test(given)) {
+            throw new Error(`Filename "${given}" is not an abapGit-style name (e.g. zcl_foo.clas.abap, zfoo.prog.abap, zr_foo.ddls.asddls).`);
+        }
+        return given.toLowerCase();
+    }
+    const head = source
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith("*") && !l.startsWith('"'))
+        .slice(0, 5)
+        .join("\n");
+    const classMatch = /^\s*CLASS\s+(\w+)\s+DEFINITION/im.exec(head);
+    if (classMatch?.[1] !== undefined)
+        return `${classMatch[1].toLowerCase()}.clas.abap`;
+    const intfMatch = /^\s*INTERFACE\s+(\w+)/im.exec(head);
+    if (intfMatch?.[1] !== undefined)
+        return `${intfMatch[1].toLowerCase()}.intf.abap`;
+    if (/^\s*(@\w|define\s+(root\s+)?view)/im.test(head))
+        return "zsnippet.ddls.asddls";
+    if (/^\s*(managed|unmanaged|abstract|projection|interface;)/im.test(head))
+        return "zsnippet.bdef.asbdef";
+    const progMatch = /^\s*(REPORT|PROGRAM)\s+(\w+)/im.exec(head);
+    if (progMatch?.[2] !== undefined)
+        return `${progMatch[2].toLowerCase()}.prog.abap`;
+    return "zsnippet.prog.abap";
+}
+function boundFiles(files) {
+    if (files.length === 0)
+        throw new Error("Provide at least one source file.");
+    if (files.length > MAX_FILES)
+        throw new Error(`At most ${MAX_FILES} files per call.`);
+    const used = new Set();
+    return files.map((f) => {
+        if (f.source.length > MAX_FILE_CHARS) {
+            throw new Error(`File ${f.filename ?? "(unnamed)"} exceeds ${MAX_FILE_CHARS} characters; split it or lint the relevant part.`);
+        }
+        let filename = inferFilename(f.source, f.filename);
+        if (used.has(filename)) {
+            // Identical names would silently overwrite each other in the registry.
+            // Generic snippet fallbacks get a unique suffix; names derived from a
+            // declaration (or given explicitly) are a caller error — two files
+            // can't define the same object.
+            if (f.filename === undefined && filename.startsWith("zsnippet.")) {
+                let n = 2;
+                while (used.has(filename.replace("zsnippet.", `zsnippet${n}.`)))
+                    n += 1;
+                filename = filename.replace("zsnippet.", `zsnippet${n}.`);
+            }
+            else {
+                throw new Error(`Duplicate filename "${filename}" — each file must define a distinct object; pass unique filenames.`);
+            }
+        }
+        used.add(filename);
+        return { filename, source: f.source };
+    });
+}
+function buildConfig(opts) {
+    let raw;
+    if (opts.preset === "syntax-only") {
+        raw = {
+            global: { files: "/**/*" },
+            syntax: { version: opts.version, errorNamespace: "^(Z|Y)" },
+            rules: { parser_error: true, cds_parser_error: true },
+        };
+    }
+    else {
+        const def = abaplint.Config.getDefault().get();
+        def.syntax.version = opts.version;
+        if (opts.preset === "style") {
+            // Semantic whole-program checks false-positive on isolated snippets.
+            def.rules["check_syntax"] = false;
+        }
+        raw = def;
+    }
+    if (opts.rules !== undefined) {
+        const rules = raw["rules"];
+        for (const [k, v] of Object.entries(opts.rules))
+            rules[k] = v;
+    }
+    return new abaplint.Config(JSON.stringify(raw));
+}
+export function runAbaplint(files, opts) {
+    const bounded = boundFiles(files);
+    const registry = new abaplint.Registry(buildConfig(opts));
+    const lines = new Map();
+    for (const f of bounded) {
+        registry.addFile(new abaplint.MemoryFile(f.filename, f.source));
+        lines.set(f.filename, f.source.split("\n"));
+    }
+    registry.parse();
+    const issues = registry.findIssues();
+    const findings = issues.slice(0, MAX_FINDINGS).map((issue) => {
+        const start = issue.getStart();
+        const fileLines = lines.get(issue.getFilename());
+        const excerpt = (fileLines?.[start.getRow() - 1] ?? "").trim().slice(0, 100);
+        return {
+            rule: issue.getKey(),
+            message: issue.getMessage(),
+            severity: String(issue.getSeverity()),
+            file: issue.getFilename(),
+            line: start.getRow(),
+            column: start.getCol(),
+            excerpt,
+            docsUrl: `https://rules.abaplint.org/${issue.getKey()}/`,
+        };
+    });
+    return { findings, truncated: issues.length > MAX_FINDINGS, fileCount: bounded.length };
+}

package/dist/abap/formatter.d.ts

@@ -0,0 +1 @@
+export declare function formatAbap(source: string, filename?: string): string;

package/dist/abap/formatter.js

@@ -0,0 +1,38 @@
+/**
+ * Pretty-print ABAP via abaplint's PrettyPrinter (keyword casing + indent).
+ * Only meaningful for ABAP sources — CDS/BDEF artifacts are not reformatted.
+ */
+import * as abaplint from "@abaplint/core";
+import { invalidInput } from "../errors.js";
+import { inferFilename, MAX_FILE_CHARS } from "./engine.js";
+export function formatAbap(source, filename) {
+    if (source.length > MAX_FILE_CHARS) {
+        throw invalidInput(`Source exceeds ${MAX_FILE_CHARS} characters.`);
+    }
+    const name = inferFilename(source, filename);
+    if (!name.endsWith(".abap")) {
+        throw invalidInput(`format_abap handles ABAP sources only (got "${name}"). CDS and behavior definitions are not reformatted.`);
+    }
+    const config = abaplint.Config.getDefault();
+    const registry = new abaplint.Registry(config);
+    registry.addFile(new abaplint.MemoryFile(name, source));
+    registry.parse();
+    const obj = registry.getFirstObject();
+    if (!(obj instanceof abaplint.ABAPObject)) {
+        throw invalidInput("Could not parse the source as an ABAP object.");
+    }
+    const file = obj.getABAPFiles()[0];
+    if (file === undefined) {
+        throw invalidInput("Could not parse the source as an ABAP object.");
+    }
+    // "Fails cleanly on source it cannot parse" is the tool contract — returning
+    // broken code as "formatted" would launder syntax errors. Gate on the
+    // parse/structure issues only (style findings are not format blockers).
+    const SYNTAX_KEYS = new Set(["parser_error", "structure", "cds_parser_error"]);
+    const syntaxIssues = registry.findIssues().filter((i) => SYNTAX_KEYS.has(i.getKey()));
+    const firstIssue = syntaxIssues[0];
+    if (firstIssue !== undefined) {
+        throw invalidInput(`Source does not parse cleanly (${syntaxIssues.length} syntax/structure issue(s)); fix before formatting. First: line ${firstIssue.getStart().getRow()}: ${firstIssue.getMessage()}`);
+    }
+    return new abaplint.PrettyPrinter(file, config).run();
+}

package/dist/abap/outline.d.ts

@@ -0,0 +1,25 @@
+import type { AbapSource } from "./engine.js";
+export interface MethodOutline {
+    name: string;
+    visibility: "public" | "protected" | "private";
+}
+export interface ClassOutline {
+    name: string;
+    isGlobal: boolean;
+    isFinal: boolean;
+    isAbstract: boolean;
+    isForTesting: boolean;
+    superClass: string | null;
+    interfaces: string[];
+    methods: MethodOutline[];
+    attributes: string[];
+    constants: string[];
+}
+export interface FileOutline {
+    file: string;
+    classes: ClassOutline[];
+    interfaces: string[];
+    forms: string[];
+    parseable: boolean;
+}
+export declare function outlineAbap(files: AbapSource[]): FileOutline[];

package/dist/abap/outline.js

@@ -0,0 +1,70 @@
+/**
+ * Structural outline of ABAP sources — lets an agent navigate a large class
+ * or legacy include without reading every line into context.
+ */
+import * as abaplint from "@abaplint/core";
+import { inferFilename, MAX_FILE_CHARS, MAX_FILES } from "./engine.js";
+import { invalidInput } from "../errors.js";
+const VISIBILITY = {
+    1: "private",
+    2: "protected",
+    3: "public",
+};
+export function outlineAbap(files) {
+    if (files.length === 0)
+        throw invalidInput("Provide at least one source file.");
+    if (files.length > MAX_FILES)
+        throw invalidInput(`At most ${MAX_FILES} files per call.`);
+    const config = abaplint.Config.getDefault();
+    const registry = new abaplint.Registry(config);
+    const names = [];
+    for (const f of files) {
+        if (f.source.length > MAX_FILE_CHARS) {
+            throw invalidInput(`File ${f.filename ?? "(unnamed)"} exceeds ${MAX_FILE_CHARS} characters.`);
+        }
+        const name = inferFilename(f.source, f.filename);
+        names.push(name);
+        registry.addFile(new abaplint.MemoryFile(name, f.source));
+    }
+    registry.parse();
+    const out = [];
+    for (const name of names) {
+        let found = false;
+        for (const obj of registry.getObjects()) {
+            if (!(obj instanceof abaplint.ABAPObject))
+                continue;
+            for (const file of obj.getABAPFiles()) {
+                if (file.getFilename() !== name)
+                    continue;
+                found = true;
+                const info = file.getInfo();
+                out.push({
+                    file: name,
+                    parseable: true,
+                    classes: info.listClassDefinitions().map((c) => ({
+                        name: c.name,
+                        isGlobal: c.isGlobal,
+                        isFinal: c.isFinal,
+                        isAbstract: c.isAbstract,
+                        isForTesting: c.isForTesting,
+                        superClass: c.superClassName?.toLowerCase() ?? null,
+                        interfaces: c.interfaces.map((i) => i.name.toLowerCase()),
+                        methods: c.methods.map((m) => ({
+                            name: m.name,
+                            visibility: VISIBILITY[m.visibility] ?? "private",
+                        })),
+                        attributes: c.attributes.map((a) => a.name),
+                        constants: c.constants.map((k) => k.name),
+                    })),
+                    interfaces: info.listInterfaceDefinitions().map((i) => i.name),
+                    forms: info.listFormDefinitions().map((f) => f.name),
+                });
+            }
+        }
+        if (!found) {
+            // Non-ABAP artifacts (CDS, BDEF) or unparseable sources get an empty outline.
+            out.push({ file: name, parseable: false, classes: [], interfaces: [], forms: [] });
+        }
+    }
+    return out;
+}

package/dist/abap/readiness.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ABAP Cloud / Clean Core readiness — the dual-run diff.
+ *
+ * One abaplint pass at `version: Cloud` and one at a classic baseline
+ * (default v758). A finding present at Cloud but absent at the baseline is a
+ * *cloud blocker* (the statement is fine classic ABAP that ABAP Cloud no
+ * 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.
+ */
+import type { AbapSource, AbapVersion, Finding } from "./engine.js";
+export interface ReadinessCategory {
+    category: string;
+    label: string;
+    count: number;
+    findings: Finding[];
+}
+export interface ReadinessReport {
+    verdict: "ready" | "minor-rework" | "moderate-rework" | "significant-rework";
+    score: number;
+    cloudBlockerCount: number;
+    categories: ReadinessCategory[];
+    /** Findings that fail even at the classic baseline — fix these first; they are not migration items. */
+    brokenAtBaseline: Finding[];
+    baselineVersion: AbapVersion;
+    scopeNote: string;
+}
+export declare const SCOPE_NOTE: string;
+export declare function checkCloudReadiness(files: AbapSource[], baselineVersion?: AbapVersion): ReadinessReport;

package/dist/abap/readiness.js

@@ -0,0 +1,56 @@
+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). " +
+    "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) {
+    const head = excerpt.toUpperCase();
+    if (/^(WRITE|ULINE|SKIP|FORMAT|NEW-PAGE|TOP-OF-PAGE|END-OF-PAGE|PRINT-CONTROL)\b/.test(head))
+        return { category: "list-output", label: "Classic list output (WRITE…) — no UI in ABAP Cloud; expose data via RAP/OData instead" };
+    if (/^(CALL SCREEN|SET SCREEN|LEAVE SCREEN|MODULE|LOOP AT SCREEN|SET PF-STATUS|SET TITLEBAR|CALL DIALOG|SUPPRESS DIALOG)\b/.test(head))
+        return { category: "dynpro", label: "Dynpro / classic UI — rebuild the UI as a Fiori app on a RAP service" };
+    if (/^(SELECT-OPTIONS|PARAMETERS|SELECTION-SCREEN|AT SELECTION-SCREEN|INITIALIZATION|START-OF-SELECTION|END-OF-SELECTION|AT LINE-SELECTION|AT USER-COMMAND)\b/.test(head))
+        return { category: "report-events", label: "Report / selection-screen events — wrap the logic in a class; use RAP or an application job" };
+    if (/^(REPORT|PROGRAM|SUBMIT)\b/.test(head))
+        return { category: "report-program", label: "Executable program statements — ABAP Cloud has classes only; SUBMIT has no released equivalent" };
+    if (/^(EXEC SQL|ENDEXEC)\b/.test(head))
+        return { category: "native-sql", label: "Native SQL — use ABAP SQL (or AMDP where released)" };
+    if (/^(CALL FUNCTION .*DESTINATION|CALL FUNCTION .*STARTING NEW TASK|RECEIVE RESULTS)\b/.test(head))
+        return { category: "rfc", label: "Direct RFC patterns — use released connectivity (bgPF, HTTP, released RFC wrappers)" };
+    if (/^(FORM|PERFORM|ENDFORM)\b/.test(head))
+        return { category: "subroutines", label: "FORM subroutines — obsolete; move logic into class methods" };
+    if (/^(CALL TRANSACTION|LEAVE TO TRANSACTION|SET PARAMETER|GET PARAMETER|AUTHORITY-CHECK)\b/.test(head))
+        return { category: "transaction-glue", label: "Transaction / SPA-GPA / classic auth glue — re-model on released APIs" };
+    return { category: "other", label: "Other statements ABAP Cloud does not allow" };
+}
+export function checkCloudReadiness(files, baselineVersion = "v758") {
+    const cloud = runAbaplint(files, { version: "Cloud", preset: "syntax-only" });
+    const baseline = runAbaplint(files, { version: baselineVersion, preset: "syntax-only" });
+    const baselineKeys = new Set(baseline.findings.map((f) => `${f.file}:${f.line}:${f.rule}`));
+    const blockers = [];
+    for (const f of cloud.findings) {
+        if (!baselineKeys.has(`${f.file}:${f.line}:${f.rule}`))
+            blockers.push(f);
+    }
+    const byCategory = new Map();
+    for (const f of blockers) {
+        const { category, label } = categorize(f.excerpt);
+        const entry = byCategory.get(category) ?? { category, label, count: 0, findings: [] };
+        entry.count += 1;
+        entry.findings.push(f);
+        byCategory.set(category, entry);
+    }
+    const n = blockers.length;
+    // Transparent, documented formula — a conversation starter, not an oracle.
+    const score = Math.max(0, 100 - 5 * n);
+    const verdict = n === 0 ? "ready" : n <= 5 ? "minor-rework" : n <= 20 ? "moderate-rework" : "significant-rework";
+    return {
+        verdict,
+        score,
+        cloudBlockerCount: n,
+        categories: [...byCategory.values()].sort((a, b) => b.count - a.count),
+        brokenAtBaseline: baseline.findings,
+        baselineVersion,
+        scopeNote: SCOPE_NOTE,
+    };
+}

package/dist/abap/rules.d.ts

@@ -0,0 +1,15 @@
+export interface RuleSummary {
+    key: string;
+    title: string;
+    shortDescription: string;
+    tags: string[];
+    docsUrl: string;
+}
+export interface RuleDetail extends RuleSummary {
+    extendedInformation: string;
+}
+export declare function listRules(query?: string, tag?: string): RuleSummary[];
+export declare function explainRule(key: string): RuleDetail & {
+    badExample?: string;
+    goodExample?: string;
+};

package/dist/abap/rules.js

@@ -0,0 +1,51 @@
+/**
+ * Rule catalog — thin projection over abaplint's own rule metadata, so the
+ * documentation an agent reads is the analyzer's, not a copy that can drift.
+ */
+import * as abaplint from "@abaplint/core";
+import { notFound } from "../errors.js";
+function metadata() {
+    return abaplint.ArtifactsRules.getRules().map((r) => r.getMetadata());
+}
+function toSummary(m) {
+    return {
+        key: m.key,
+        title: m.title,
+        shortDescription: m.shortDescription,
+        tags: m.tags ?? [],
+        docsUrl: `https://rules.abaplint.org/${m.key}/`,
+    };
+}
+export function listRules(query, tag) {
+    const q = query?.toLowerCase();
+    return metadata()
+        .filter((m) => {
+        if (tag !== undefined && !(m.tags ?? []).some((t) => t.toLowerCase() === tag.toLowerCase()))
+            return false;
+        if (q !== undefined) {
+            const hay = `${m.key} ${m.title} ${m.shortDescription}`.toLowerCase();
+            if (!hay.includes(q))
+                return false;
+        }
+        return true;
+    })
+        .map(toSummary)
+        .sort((a, b) => a.key.localeCompare(b.key));
+}
+export function explainRule(key) {
+    const m = metadata().find((x) => x.key === key.toLowerCase());
+    if (m === undefined) {
+        throw notFound(`No abaplint rule named "${key}". Use list_abap_rules to browse valid keys.`, {
+            key,
+        });
+    }
+    const detail = {
+        ...toSummary(m),
+        extendedInformation: m.extendedInformation ?? "",
+    };
+    if (m.badExample !== undefined)
+        detail.badExample = m.badExample;
+    if (m.goodExample !== undefined)
+        detail.goodExample = m.goodExample;
+    return detail;
+}

package/dist/abap/scaffold.d.ts

@@ -0,0 +1,55 @@
+/**
+ * RAP managed-BO scaffolder.
+ *
+ * Generates the canonical ABAP-Cloud stack for one root entity — the same
+ * shape as SAP's /DMO reference apps and the ADT wizards:
+ *
+ *   root view entity (ZR_)  →  behavior definition (managed, strict(2))
+ *   projection view  (ZC_)  →  projection behavior definition
+ *   behavior implementation class (ZBP_) + handler locals
+ *   metadata extension (UI annotations)  +  service definition (ZUI_…_V4)
+ *
+ * Everything the generator emits that abaplint can parse is round-tripped
+ * through abaplint at version Cloud before it is returned: the generator and
+ * the linter share one parser, so the scaffold can never drift into syntax
+ * the lint would reject. BDEF/SRVD artifacts are outside abaplint's checked
+ * surface (verified empirically) — those are covered by golden tests and
+ * marked validated:"template".
+ */
+import type { Finding } from "./engine.js";
+export interface ScaffoldField {
+    /** snake_case table field name, e.g. "agency_id". */
+    name: string;
+    /** Suggested DDL type for the table source, e.g. "abap.char(6)". */
+    type?: string | undefined;
+}
+export interface ScaffoldOptions {
+    /** Entity in UpperCamelCase, e.g. "Travel". Drives all artifact names. */
+    entityName: string;
+    /** Persistent SQL table, e.g. "ztravel". */
+    sqlTable: string;
+    /** snake_case key field name, e.g. "travel_id". */
+    keyField: string;
+    /** True (default): UUID key, managed numbering. False: caller supplies the key on create. */
+    managedUuidKey: boolean;
+    fields: ScaffoldField[];
+    draft: boolean;
+    /** Dev namespace prefix, "Z" or "Y". */
+    prefix: "Z" | "Y";
+}
+export interface ScaffoldFile {
+    filename: string;
+    content: string;
+    /** "abaplint" = machine-validated through the parser; "template" = golden-tested template. */
+    validated: "abaplint" | "template";
+}
+export interface ScaffoldResult {
+    files: ScaffoldFile[];
+    activationOrder: string[];
+    nextSteps: string[];
+    suggestedTableDdl: string;
+    /** Non-empty only if the generated sources failed abaplint — should never happen. */
+    validationIssues: Finding[];
+}
+export declare function snakeToCamel(snake: string): string;
+export declare function scaffoldRapBo(opts: ScaffoldOptions): ScaffoldResult;