abap-mcp 0.3.2 → 0.4.1

package/README.md

@@ -18,11 +18,12 @@ of their time where the *files* are — editing abapGit repos, reviewing diffs,
 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`
+- *"Does this ABAP parse? Is it clean? How does it perform?"* → `lint_abap` (+ focus packs)
+- *"How far is this classic report from ABAP Cloud? Grade it."* → `check_cloud_readiness` (A–D)
+- *"Did this rework make the code better or worse?"* → `compare_abap`
 - *"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`
+- *"What's in this 4,000-line class? Draw it."* → `get_abap_outline` (+ Mermaid)
 
 ## Quickstart
 
@@ -54,9 +55,12 @@ Every tool is also a subcommand, so it works in terminals and CI where no MCP cl
 
 ```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 lint src/ --focus Performance      # themed pass: Performance | Security | Styleguide
+npx abap-mcp lint src/ --rules-file org.json    # your org's abaplint rule pack, same engine
+npx abap-mcp readiness src/ --fail-below 80     # repo-level ABAP Cloud readiness, scored + graded A–D
+npx abap-mcp compare old/ new/                  # rework verdict: findings resolved/introduced, grade movement
 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 outline src/zcl_monster.clas.abap  # navigate big objects (--mermaid for a diagram)
 npx abap-mcp released MARA I_Product            # released-API status + CDS successor
 npx abap-mcp explain exit_or_check              # rule rationale
 ```
@@ -77,14 +81,15 @@ 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. 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. |
+| `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 for org rule packs; `focus` lens (`Performance` / `Security` / `Styleguide`) for themed reviews. |
+| `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 **and a density-banded A–D tech-debt grade**; code broken at the baseline is reported separately, not counted as migration work. 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. |
+| `compare_abap` | Before/after verdict on a rework: lint findings resolved vs introduced (matched by content, so moved code isn't noise), blocker/score/grade movement, and classes/methods/FORMs added or removed. The objective referee for refactors and AI rewrites. |
 | `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. |
 | `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. |
+| `get_abap_outline` | Classes/methods/visibility/interfaces/FORMs of a source — navigate big objects without reading them whole. Optional Mermaid classDiagram output for instant structure visuals. |
 
 ## Honesty box — what this is *not*
 
@@ -110,7 +115,7 @@ loop condition), per-repo `.mcp.json`, and a GitHub Actions quality gate for aba
 
 ```bash
 npm install
-npm run check     # typecheck + 122 tests + build — the CI gate
+npm run check     # typecheck + 149 tests + build — the CI gate
 node dist/cli.js  # stdio MCP server
 npx @modelcontextprotocol/inspector --cli node dist/cli.js --method tools/list
 ```
@@ -118,7 +123,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
-eight tools 100/100).
+nine tools 100/100).
 
 ## Design
 

package/dist/abap/compare.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Before/after comparison of ABAP sources — the deterministic half of a
+ * rework review.
+ *
+ * Findings are matched by CONTENT (rule + message + offending line text),
+ * never by line number, so code that merely moved does not show up as
+ * regressed or fixed. Blocker count / score / grade movement comes from the
+ * same objective dual-parse diff check_cloud_readiness uses; this module
+ * adds no judgment of its own.
+ */
+import type { AbapSource, AbapVersion, Finding, FocusTag } from "./engine.js";
+import type { ReadinessGrade } from "./readiness.js";
+export interface CompareSide {
+    findingCount: number;
+    cloudBlockerCount: number;
+    score: number;
+    grade: ReadinessGrade;
+}
+export interface OutlineChanges {
+    classesAdded: string[];
+    classesRemoved: string[];
+    /** "class.method", lower-cased. */
+    methodsAdded: string[];
+    methodsRemoved: string[];
+    formsAdded: string[];
+    formsRemoved: string[];
+}
+export interface CompareOptions {
+    version: AbapVersion;
+    preset: "style" | "full" | "syntax-only";
+    rules?: Record<string, unknown> | undefined;
+    focus?: FocusTag | undefined;
+    /** Baseline for the readiness halves; defaults to v758. */
+    baselineVersion?: AbapVersion | undefined;
+}
+export interface CompareReport {
+    /** Findings present before but gone after — improvements. */
+    resolved: Finding[];
+    /** Findings present only after — regressions. */
+    introduced: Finding[];
+    /** Findings present on both sides (content-matched). */
+    unchangedCount: number;
+    before: CompareSide;
+    after: CompareSide;
+    outlineChanges: OutlineChanges;
+    matchNote: string;
+}
+export declare const MATCH_NOTE: string;
+export declare function compareAbap(before: AbapSource[], after: AbapSource[], opts: CompareOptions): CompareReport;

package/dist/abap/compare.js

@@ -0,0 +1,80 @@
+import { runAbaplint } from "./engine.js";
+import { outlineAbap } from "./outline.js";
+import { checkCloudReadiness } from "./readiness.js";
+export const MATCH_NOTE = "Findings are matched by rule + message + offending line text, not line numbers — moved-but-unchanged code does " +
+    "not count as resolved or introduced. Lint numbers use the requested preset; blocker count, score and grade come " +
+    "from the same objective dual-parse diff as check_cloud_readiness. Lint-clean does not mean functionally " +
+    "equivalent — behavior can change while every number here improves.";
+const findingKey = (f) => [f.rule, f.message, f.excerpt].join("\u0000");
+function diffFindings(before, after) {
+    // Multiset match: two identical findings on the before side need two
+    // matches on the after side to count as unchanged.
+    const pool = new Map();
+    for (const f of before) {
+        const arr = pool.get(findingKey(f)) ?? [];
+        arr.push(f);
+        pool.set(findingKey(f), arr);
+    }
+    const introduced = [];
+    let unchangedCount = 0;
+    for (const f of after) {
+        const arr = pool.get(findingKey(f));
+        if (arr !== undefined && arr.length > 0) {
+            arr.pop();
+            unchangedCount += 1;
+        }
+        else {
+            introduced.push(f);
+        }
+    }
+    return { resolved: [...pool.values()].flat(), introduced, unchangedCount };
+}
+function outlineNames(files) {
+    const classes = new Set();
+    const methods = new Set();
+    const forms = new Set();
+    for (const o of outlineAbap(files)) {
+        for (const c of o.classes) {
+            classes.add(c.name.toLowerCase());
+            for (const m of c.methods)
+                methods.add(`${c.name}.${m.name}`.toLowerCase());
+        }
+        for (const f of o.forms)
+            forms.add(f.toLowerCase());
+    }
+    return { classes, methods, forms };
+}
+const addedFrom = (a, b) => [...b].filter((x) => !a.has(x)).sort();
+const side = (findingCount, readiness) => ({
+    findingCount,
+    cloudBlockerCount: readiness.cloudBlockerCount,
+    score: readiness.score,
+    grade: readiness.grade,
+});
+export function compareAbap(before, after, opts) {
+    const lintOpts = { version: opts.version, preset: opts.preset, rules: opts.rules, focus: opts.focus };
+    const beforeLint = runAbaplint(before, lintOpts);
+    const afterLint = runAbaplint(after, lintOpts);
+    const { resolved, introduced, unchangedCount } = diffFindings(beforeLint.findings, afterLint.findings);
+    const baseline = opts.baselineVersion ?? "v758";
+    const beforeReadiness = checkCloudReadiness(before, baseline);
+    const afterReadiness = checkCloudReadiness(after, baseline);
+    const b = outlineNames(before);
+    const a = outlineNames(after);
+    return {
+        resolved,
+        introduced,
+        unchangedCount,
+        before: side(beforeLint.findings.length, beforeReadiness),
+        after: side(afterLint.findings.length, afterReadiness),
+        outlineChanges: {
+            classesAdded: addedFrom(b.classes, a.classes),
+            classesRemoved: addedFrom(a.classes, b.classes),
+            methodsAdded: addedFrom(b.methods, a.methods),
+            methodsRemoved: addedFrom(a.methods, b.methods),
+            formsAdded: addedFrom(b.forms, a.forms),
+            formsRemoved: addedFrom(a.forms, b.forms),
+        },
+        matchNote: MATCH_NOTE,
+    };
+}

package/dist/abap/engine.d.ts

@@ -24,10 +24,22 @@ export type AbapVersion = (typeof ABAP_VERSIONS)[number];
  * statement, so agents can lint snippets without knowing the convention.
  */
 export declare function inferFilename(source: string, given?: string): string;
+/**
+ * Curated rule-pack lenses — abaplint's own tags, so the pack is the
+ * analyzer's taxonomy, not a hand-maintained list that can drift.
+ */
+export declare const FOCUS_TAGS: readonly ["Performance", "Security", "Styleguide"];
+export type FocusTag = (typeof FOCUS_TAGS)[number];
 export interface RunOptions {
     version: AbapVersion;
-    /** abaplint rule config; merged over the preset. */
+    /** abaplint rule config; merged over the preset (and over a focus filter). */
     rules?: Record<string, unknown> | undefined;
+    /**
+     * Keep only rules carrying this abaplint tag (parser errors always stay
+     * on — focused findings on unparseable code would be garbage). Ignored
+     * for "syntax-only", which has no opinionated rules to focus.
+     */
+    focus?: FocusTag | undefined;
     /**
      * "style"       — abaplint's default ruleset minus whole-program semantic
      *                 checks, so isolated snippets don't drown in noise about

package/dist/abap/engine.js

@@ -10,6 +10,7 @@
  *    Callers may omit them; we infer from the source's leading statement.
  */
 import * as abaplint from "@abaplint/core";
+import { listRules } from "./rules.js";
 export const MAX_FILES = 32;
 export const MAX_FILE_CHARS = 100_000;
 export const MAX_FINDINGS = 500;
@@ -89,6 +90,11 @@ function boundFiles(files) {
         return { filename, source: f.source };
     });
 }
+/**
+ * Curated rule-pack lenses — abaplint's own tags, so the pack is the
+ * analyzer's taxonomy, not a hand-maintained list that can drift.
+ */
+export const FOCUS_TAGS = ["Performance", "Security", "Styleguide"];
 function buildConfig(opts) {
     let raw;
     if (opts.preset === "syntax-only") {
@@ -107,7 +113,16 @@ function buildConfig(opts) {
         }
         raw = def;
     }
+    if (opts.focus !== undefined && opts.preset !== "syntax-only") {
+        const tagged = new Set(listRules(undefined, opts.focus).map((r) => r.key));
+        const rules = raw["rules"];
+        for (const key of Object.keys(rules)) {
+            if (!tagged.has(key) && key !== "parser_error" && key !== "cds_parser_error")
+                rules[key] = false;
+        }
+    }
     if (opts.rules !== undefined) {
+        // Explicit per-rule overrides win over the preset AND over a focus filter.
         const rules = raw["rules"];
         for (const [k, v] of Object.entries(opts.rules))
             rules[k] = v;

package/dist/abap/outline.d.ts

@@ -23,3 +23,11 @@ export interface FileOutline {
     parseable: boolean;
 }
 export declare function outlineAbap(files: AbapSource[]): FileOutline[];
+/**
+ * Render outlines as a Mermaid classDiagram: classes with method visibility
+ * (+/#/-) and attributes, inheritance (<|--), interface realization (<|..),
+ * and legacy FORMs as one pseudo-class per file. Deterministic text out —
+ * paste into any Mermaid renderer (GitHub, docs sites, diagram tools) for
+ * the visual; nothing here draws pixels.
+ */
+export declare function outlineToMermaid(outlines: FileOutline[]): string;

package/dist/abap/outline.js

@@ -68,3 +68,59 @@ export function outlineAbap(files) {
     }
     return out;
 }
+const VIS_PREFIX = {
+    public: "+",
+    protected: "#",
+    private: "-",
+};
+/** Mermaid identifiers cannot carry ABAP's ~ / namespace slashes / dots. */
+function mermaidName(name) {
+    return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+/**
+ * Render outlines as a Mermaid classDiagram: classes with method visibility
+ * (+/#/-) and attributes, inheritance (<|--), interface realization (<|..),
+ * and legacy FORMs as one pseudo-class per file. Deterministic text out —
+ * paste into any Mermaid renderer (GitHub, docs sites, diagram tools) for
+ * the visual; nothing here draws pixels.
+ */
+export function outlineToMermaid(outlines) {
+    const lines = ["classDiagram"];
+    const declaredInterfaces = new Set();
+    const declareInterface = (name) => {
+        const id = mermaidName(name);
+        if (declaredInterfaces.has(id))
+            return;
+        declaredInterfaces.add(id);
+        lines.push(`  class ${id} {`, "    <<interface>>", "  }");
+    };
+    for (const o of outlines) {
+        for (const i of o.interfaces)
+            declareInterface(i);
+        for (const c of o.classes) {
+            const id = mermaidName(c.name);
+            lines.push(`  class ${id} {`);
+            if (c.isAbstract)
+                lines.push("    <<abstract>>");
+            for (const m of c.methods)
+                lines.push(`    ${VIS_PREFIX[m.visibility]}${mermaidName(m.name)}()`);
+            for (const a of c.attributes)
+                lines.push(`    ${mermaidName(a)}`);
+            lines.push("  }");
+            if (c.superClass !== null)
+                lines.push(`  ${mermaidName(c.superClass)} <|-- ${id}`);
+            for (const i of c.interfaces) {
+                declareInterface(i);
+                lines.push(`  ${mermaidName(i)} <|.. ${id}`);
+            }
+        }
+        if (o.forms.length > 0) {
+            const id = `${mermaidName(o.file.replace(/\..*$/, ""))}_forms`;
+            lines.push(`  class ${id} {`);
+            for (const f of o.forms)
+                lines.push(`    +${mermaidName(f)}()`);
+            lines.push("  }");
+        }
+    }
+    return lines.join("\n");
+}

package/dist/abap/readiness.d.ts

@@ -40,10 +40,24 @@ export interface ReleasedApiFinding {
     /** Human-facing explanation of why this was flagged. */
     note: string;
 }
+/** Letter grade for tech-debt assessments — a banding of blocker density. */
+export type ReadinessGrade = "A" | "B" | "C" | "D";
+/**
+ * Band the objective blocker count into an A–D Clean Core tech-debt grade,
+ * normalized by file count so a single object and a whole package grade on
+ * the same scale: A = no blockers, B = ≤ 0.5 blockers/file, C = ≤ 2
+ * blockers/file, D = worse. Same number as the score, different lens —
+ * nothing subjective is mixed in.
+ */
+export declare function gradeReadiness(cloudBlockerCount: number, fileCount: number): ReadinessGrade;
 export interface ReadinessReport {
     verdict: "ready" | "minor-rework" | "moderate-rework" | "significant-rework";
     score: number;
+    /** A–D banding of blocker density (blockers / files) — see gradeReadiness. */
+    grade: ReadinessGrade;
     cloudBlockerCount: number;
+    /** Files analyzed — the denominator of the grade's density banding. */
+    fileCount: number;
     categories: ReadinessCategory[];
     /** Findings that fail even at the classic baseline — fix these first; they are not migration items. */
     brokenAtBaseline: Finding[];

package/dist/abap/readiness.js

@@ -1,5 +1,22 @@
 import { extractObjectReferences, runAbaplint } from "./engine.js";
 import { lookupReleased, RELEASED_API_SNAPSHOT, suggestSuccessor } from "./released.js";
+/**
+ * Band the objective blocker count into an A–D Clean Core tech-debt grade,
+ * normalized by file count so a single object and a whole package grade on
+ * the same scale: A = no blockers, B = ≤ 0.5 blockers/file, C = ≤ 2
+ * blockers/file, D = worse. Same number as the score, different lens —
+ * nothing subjective is mixed in.
+ */
+export function gradeReadiness(cloudBlockerCount, fileCount) {
+    if (cloudBlockerCount === 0)
+        return "A";
+    const perFile = cloudBlockerCount / Math.max(1, fileCount);
+    if (perFile <= 0.5)
+        return "B";
+    if (perFile <= 2)
+        return "C";
+    return "D";
+}
 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 " +
@@ -52,7 +69,9 @@ export function checkCloudReadiness(files, baselineVersion = "v758") {
     return {
         verdict,
         score,
+        grade: gradeReadiness(n, files.length),
         cloudBlockerCount: n,
+        fileCount: files.length,
         categories: [...byCategory.values()].sort((a, b) => b.count - a.count),
         brokenAtBaseline: baseline.findings,
         releasedApiFindings: computeReleasedApiFindings(files, baselineVersion),

package/dist/abap.tools.d.ts

@@ -31,6 +31,11 @@ export declare const lintAbap: import("./tool.js").ToolSpec<{
         "syntax-only": "syntax-only";
     }>>;
     rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    focus: z.ZodOptional<z.ZodEnum<{
+        Performance: "Performance";
+        Security: "Security";
+        Styleguide: "Styleguide";
+    }>>;
 }>;
 export declare const checkCloudReadinessTool: import("./tool.js").ToolSpec<{
     files: z.ZodArray<z.ZodObject<{
@@ -81,6 +86,7 @@ export declare const getAbapOutline: import("./tool.js").ToolSpec<{
         filename: z.ZodOptional<z.ZodString>;
         source: z.ZodString;
     }, z.core.$strip>>;
+    mermaid: z.ZodDefault<z.ZodBoolean>;
 }>;
 export declare const checkReleasedApiTool: import("./tool.js").ToolSpec<{
     objects: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -88,6 +94,39 @@ export declare const checkReleasedApiTool: import("./tool.js").ToolSpec<{
         type: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>]>>;
 }>;
+export declare const compareAbapTool: import("./tool.js").ToolSpec<{
+    before: z.ZodArray<z.ZodObject<{
+        filename: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+    }, z.core.$strip>>;
+    after: z.ZodArray<z.ZodObject<{
+        filename: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+    }, z.core.$strip>>;
+    abapVersion: z.ZodDefault<z.ZodEnum<{
+        Cloud: "Cloud";
+        v750: "v750";
+        v751: "v751";
+        v752: "v752";
+        v753: "v753";
+        v754: "v754";
+        v755: "v755";
+        v756: "v756";
+        v757: "v757";
+        v758: "v758";
+    }>>;
+    preset: z.ZodDefault<z.ZodEnum<{
+        style: "style";
+        full: "full";
+        "syntax-only": "syntax-only";
+    }>>;
+    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    focus: z.ZodOptional<z.ZodEnum<{
+        Performance: "Performance";
+        Security: "Security";
+        Styleguide: "Styleguide";
+    }>>;
+}>;
 /** 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

@@ -7,9 +7,10 @@
  * documentation is this file — treat it as the public API surface.
  */
 import { z } from "zod";
-import { ABAP_VERSIONS, runAbaplint } from "./abap/engine.js";
+import { compareAbap } from "./abap/compare.js";
+import { ABAP_VERSIONS, FOCUS_TAGS, runAbaplint } from "./abap/engine.js";
 import { formatAbap } from "./abap/formatter.js";
-import { outlineAbap } from "./abap/outline.js";
+import { outlineAbap, outlineToMermaid } 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";
@@ -29,6 +30,22 @@ const filesField = z
     .max(32)
     .describe("Source files to analyze, up to 32 per call, 100k chars each.");
 const sevenSampleAbap = 'lint_abap({ "files": [ { "source": "REPORT ztest.\\nDATA foo TYPE i.\\nIF foo = 1.\\nENDIF." } ] })';
+const focusField = z
+    .enum(FOCUS_TAGS)
+    .optional()
+    .describe('Curated rule-pack lens: report only rules carrying this abaplint tag — "Performance" for a tuning pass, ' +
+    '"Security" for a security sweep, "Styleguide" for Clean ABAP adherence. Parser errors always surface. ' +
+    'Ignored with preset "syntax-only". Combine with rules to re-tune individual rules in the pack.');
+const findingShape = z.object({
+    rule: z.string().describe("abaplint rule key."),
+    message: z.string().describe("Human-readable finding."),
+    severity: z.string().describe("Error, Warning or Info."),
+    file: z.string().describe("Filename the finding is in."),
+    line: z.number().describe("1-based line."),
+    column: z.number().describe("1-based column."),
+    excerpt: z.string().describe("The offending line, trimmed."),
+    docsUrl: z.string().describe("Rule documentation at rules.abaplint.org."),
+});
 export const lintAbap = defineTool({
     name: "lint_abap",
     title: "Lint ABAP source",
@@ -38,8 +55,9 @@ export const lintAbap = defineTool({
         "anywhere near a system — it runs entirely offline on the provided text. " +
         "It does not connect to any SAP system, does not run ATC, and cannot judge whether referenced objects exist " +
         "unless you provide them in the same call (preset \"style\", the default, skips whole-program checks for that reason; " +
-        "preset \"full\" enables them when you provide every dependency). For an ABAP-Cloud migration verdict use " +
-        "check_cloud_readiness instead. " +
+        "preset \"full\" enables them when you provide every dependency). A focus tag turns a pass into a themed review " +
+        "(performance / security / Clean ABAP style) without hand-picking rules; rule overrides layer a team's own pack " +
+        "on top. For an ABAP-Cloud migration verdict use check_cloud_readiness instead. " +
         `Example: ${sevenSampleAbap}.`,
     inputSchema: {
         files: filesField,
@@ -51,19 +69,11 @@ export const lintAbap = defineTool({
         rules: z
             .record(z.string(), z.unknown())
             .optional()
-            .describe('abaplint rule overrides merged onto the preset, e.g. { "line_length": { "length": 120 }, "7bit_ascii": false }.'),
+            .describe('abaplint rule overrides merged onto the preset (and onto a focus filter), e.g. { "line_length": { "length": 120 }, "7bit_ascii": false } — encode an org\'s best-practice pack here.'),
+        focus: focusField,
     },
     outputSchema: {
-        findings: z.array(z.object({
-            rule: z.string().describe("abaplint rule key."),
-            message: z.string().describe("Human-readable finding."),
-            severity: z.string().describe("Error, Warning or Info."),
-            file: z.string().describe("Filename the finding is in."),
-            line: z.number().describe("1-based line."),
-            column: z.number().describe("1-based column."),
-            excerpt: z.string().describe("The offending line, trimmed."),
-            docsUrl: z.string().describe("Rule documentation at rules.abaplint.org."),
-        })),
+        findings: z.array(findingShape),
         truncated: z.boolean().describe("True if more than 500 findings existed and the list was cut."),
         fileCount: z.number().describe("Number of files analyzed."),
     },
@@ -83,12 +93,20 @@ export const lintAbap = defineTool({
                 rules: { line_length: { length: 120 } },
             },
         },
+        {
+            description: "Performance-focused pass over a report.",
+            arguments: {
+                files: [{ source: "REPORT zperf.\nSELECT * FROM mara INTO TABLE @DATA(lt_mara)." }],
+                focus: "Performance",
+            },
+        },
     ],
     handler: (args) => {
         const result = runAbaplint(args.files, {
             version: args.abapVersion,
             preset: args.preset,
             rules: args.rules,
+            focus: args.focus,
         });
         const text = result.findings.length === 0
             ? `No findings in ${result.fileCount} file(s).`
@@ -107,10 +125,10 @@ export const checkCloudReadinessTool = defineTool({
     description: "Assess how far ABAP source is from ABAP Cloud (Clean Core tier 1) by parsing it twice — once at a classic " +
         "baseline (default v758) and once at version Cloud — and diffing: findings that appear only at Cloud are genuine " +
         "cloud blockers (statements ABAP Cloud removed), reported in categories (dynpro, list output, native SQL, report " +
-        "events, …) with a transparent score and verdict; findings already present at the baseline are reported separately " +
-        "as broken code, not migration work. " +
-        "Use this when someone asks 'is this code cloud-ready / Clean Core compliant / S/4HANA-cloud safe' or before " +
-        "porting classic ABAP into an ABAP Cloud environment. " +
+        "events, …) with a transparent score, an A–D tech-debt grade and a verdict; findings already present at the " +
+        "baseline are reported separately as broken code, not migration work. " +
+        "Use this when someone asks 'is this code cloud-ready / Clean Core compliant / S/4HANA-cloud safe', before " +
+        "porting classic ABAP into an ABAP Cloud environment, or for a graded tech-debt assessment of an abapGit export. " +
         "It is static and parser-level: it does not check released-API usage (that needs a system's ATC), does not " +
         "connect to any SAP system, and a 'ready' verdict means no language-level blockers — not a certification. " +
         'Example: check_cloud_readiness({ "files": [ { "source": "REPORT zold.\\nWRITE: / \'hi\'." } ] }).',
@@ -123,7 +141,11 @@ export const checkCloudReadinessTool = defineTool({
             .enum(["ready", "minor-rework", "moderate-rework", "significant-rework"])
             .describe("Banded verdict from the blocker count (0 / ≤5 / ≤20 / >20)."),
         score: z.number().describe("100 − 5×blockers, floored at 0. Transparent, not an oracle."),
+        grade: z
+            .enum(["A", "B", "C", "D"])
+            .describe("Clean Core tech-debt grade banded on blocker density: A = no blockers, B = ≤ 0.5 blockers/file, C = ≤ 2 blockers/file, D = more. The same objective count as the score, sized for assessment reports."),
         cloudBlockerCount: z.number().describe("Statements valid at the baseline but not in ABAP Cloud."),
+        fileCount: z.number().describe("Files analyzed — the denominator of the grade's density banding."),
         categories: z.array(z.object({
             category: z.string().describe("Stable category id, e.g. dynpro, list-output, native-sql."),
             label: z.string().describe("What this category means and the usual remediation."),
@@ -154,7 +176,7 @@ export const checkCloudReadinessTool = defineTool({
     handler: (args) => {
         const report = checkCloudReadiness(args.files, args.baselineVersion);
         const catLine = report.categories.map((c) => `${c.category}=${c.count}`).join(", ");
-        const text = `${report.verdict} (score ${report.score}): ${report.cloudBlockerCount} cloud blocker(s)` +
+        const text = `${report.verdict} (score ${report.score}, grade ${report.grade}): ${report.cloudBlockerCount} cloud blocker(s)` +
             (catLine.length > 0 ? ` [${catLine}]` : "") +
             (report.brokenAtBaseline.length > 0
                 ? `; ${report.brokenAtBaseline.length} finding(s) broken at ${report.baselineVersion} regardless`
@@ -378,13 +400,23 @@ export const getAbapOutline = defineTool({
     description: "Return the structural outline of ABAP sources — classes (with methods, visibility, attributes, interfaces, " +
         "inheritance), interfaces, and FORM routines — without you having to read the whole file. " +
         "Use this when navigating a large class or legacy program to decide which part to read or edit next; it is the " +
-        "cheap first call before pulling thousands of lines into context. It does not return method bodies or analyze " +
+        "cheap first call before pulling thousands of lines into context. Set mermaid: true to also get the structure as " +
+        "a Mermaid classDiagram (inheritance, interface realization, method visibility) for documentation visuals. " +
+        "It does not return method bodies or analyze " +
         "code quality (use lint_abap for that), and CDS/behavior-definition files yield an empty outline. " +
         'Example: get_abap_outline({ "files": [ { "filename": "zcl_big.clas.abap", "source": "CLASS zcl_big DEFINITION…" } ] }).',
     inputSchema: {
         files: filesField,
+        mermaid: z
+            .boolean()
+            .default(false)
+            .describe("Also return the outline as Mermaid classDiagram source — render it anywhere Mermaid renders (GitHub, docs sites) for an instant structure diagram."),
     },
     outputSchema: {
+        mermaid: z
+            .string()
+            .optional()
+            .describe("Mermaid classDiagram source for all files; present only when requested."),
         outlines: z.array(z.object({
             file: z.string().describe("Filename."),
             parseable: z.boolean().describe("False when the file is not an ABAP object (or unparseable)."),
@@ -421,9 +453,13 @@ export const getAbapOutline = defineTool({
             return `${o.file}: ${parts.join("; ") || "(empty)"}`;
         })
             .join("\n");
+        const mermaid = args.mermaid ? outlineToMermaid(outlines) : undefined;
         return {
-            content: [{ type: "text", text }],
-            structuredContent: { outlines: outlines },
+            content: [{ type: "text", text: mermaid !== undefined ? `${text}\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`` : text }],
+            structuredContent: {
+                outlines: outlines,
+                ...(mermaid !== undefined ? { mermaid } : {}),
+            },
         };
     },
 });
@@ -529,10 +565,100 @@ export const checkReleasedApiTool = defineTool({
         };
     },
 });
+const compareSideShape = z.object({
+    findingCount: z.number().describe("Total lint findings on this side."),
+    cloudBlockerCount: z.number().describe("ABAP Cloud blockers on this side (objective dual-parse diff)."),
+    score: z.number().describe("Readiness score on this side (100 − 5×blockers, floored at 0)."),
+    grade: z.enum(["A", "B", "C", "D"]).describe("Density-banded Clean Core grade on this side."),
+});
+export const compareAbapTool = defineTool({
+    name: "compare_abap",
+    title: "Compare two ABAP versions",
+    description: "Compare a BEFORE and an AFTER version of ABAP source and report what a rework actually changed: lint findings " +
+        "resolved and introduced (matched by content, so moved-but-unchanged code is not noise), cloud-blocker / score / " +
+        "A–D grade movement from the same dual-parse diff as check_cloud_readiness, and structural changes — classes, " +
+        "methods and FORMs added or removed. " +
+        "Use this when reviewing a refactor, a modernization step or an AI-generated rewrite of an existing object and " +
+        "you need an objective better-or-worse verdict instead of eyeballing a diff. " +
+        "It is not a textual diff tool (use git diff to see the edits) and it cannot judge functional equivalence — " +
+        "behavior can change while every number improves; it does not connect to any SAP system. " +
+        'Example: compare_abap({ "before": [ { "source": "REPORT zr.\\nWRITE 1." } ], "after": [ { "source": "REPORT zr.\\nWRITE 2." } ] }).',
+    inputSchema: {
+        before: filesField.describe("The BEFORE sources — the current/old version of the object(s). Up to 32 files, 100k chars each."),
+        after: filesField.describe("The AFTER sources — the reworked version being judged. Up to 32 files, 100k chars each."),
+        abapVersion: VERSION_ENUM.default("v758").describe('ABAP language version both sides are linted against. "v758" (default) is current on-prem; "Cloud" is ABAP Cloud.'),
+        preset: z
+            .enum(["style", "full", "syntax-only"])
+            .default("style")
+            .describe('Lint preset applied identically to both sides: "style" (default) for isolated snippets, "full" when every referenced object is provided, "syntax-only" for parser errors only.'),
+        rules: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe('abaplint rule overrides applied to both sides, e.g. { "line_length": { "length": 120 } }.'),
+        focus: focusField,
+    },
+    outputSchema: {
+        resolved: z.array(findingShape).describe("Findings present before but gone after — improvements."),
+        introduced: z.array(findingShape).describe("Findings present only after — regressions to fix."),
+        unchangedCount: z.number().describe("Findings present on both sides (content-matched)."),
+        before: compareSideShape.describe("Lint and readiness numbers for the BEFORE side."),
+        after: compareSideShape.describe("Lint and readiness numbers for the AFTER side."),
+        outlineChanges: z.object({
+            classesAdded: z.array(z.string()).describe("Class names present only after."),
+            classesRemoved: z.array(z.string()).describe("Class names present only before."),
+            methodsAdded: z.array(z.string()).describe('Methods present only after, as "class.method".'),
+            methodsRemoved: z.array(z.string()).describe('Methods present only before, as "class.method".'),
+            formsAdded: z.array(z.string()).describe("FORM routines present only after."),
+            formsRemoved: z.array(z.string()).describe("FORM routines present only before (removing FORMs is usually progress)."),
+        }),
+        matchNote: z.string().describe("How findings were matched and what the numbers do and do not mean."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: false, idempotentHint: true },
+    examples: [
+        {
+            description: "Judge a WRITE-report rewritten as a class.",
+            arguments: {
+                before: [{ source: "REPORT zold.\nWRITE: / 'hi'." }],
+                after: [
+                    {
+                        source: "CLASS zcl_new DEFINITION PUBLIC FINAL CREATE PUBLIC.\n PUBLIC SECTION.\n METHODS get RETURNING VALUE(rv) TYPE string.\nENDCLASS.\nCLASS zcl_new IMPLEMENTATION.\n METHOD get.\n rv = 'hi'.\n ENDMETHOD.\nENDCLASS.",
+                    },
+                ],
+            },
+        },
+        {
+            description: "Performance-focused before/after check of a tuning change.",
+            arguments: {
+                before: [{ source: "REPORT zperf.\nSELECT * FROM mara INTO TABLE @DATA(lt)." }],
+                after: [{ source: "REPORT zperf.\nSELECT matnr FROM mara INTO TABLE @DATA(lt)." }],
+                focus: "Performance",
+            },
+        },
+    ],
+    handler: (args) => {
+        const report = compareAbap(args.before, args.after, {
+            version: args.abapVersion,
+            preset: args.preset,
+            rules: args.rules,
+            focus: args.focus,
+        });
+        const oc = report.outlineChanges;
+        const structural = oc.classesAdded.length + oc.classesRemoved.length + oc.methodsAdded.length + oc.methodsRemoved.length + oc.formsAdded.length + oc.formsRemoved.length;
+        const text = `${report.introduced.length} introduced, ${report.resolved.length} resolved, ${report.unchangedCount} unchanged finding(s); ` +
+            `blockers ${report.before.cloudBlockerCount}→${report.after.cloudBlockerCount}, ` +
+            `score ${report.before.score}→${report.after.score}, grade ${report.before.grade}→${report.after.grade}` +
+            (structural > 0 ? `; ${structural} structural change(s)` : "");
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: report,
+        };
+    },
+});
 /** Every tool this server exposes. (`tools` alias = the registry-export shape @mcp-kit/lint discovers.) */
 export const ALL_TOOLS = [
     lintAbap,
     checkCloudReadinessTool,
+    compareAbapTool,
     scaffoldRapBoTool,
     checkReleasedApiTool,
     listAbapRules,

package/dist/cli-commands.d.ts

@@ -16,8 +16,9 @@ export declare function mergeReadiness(reports: ReadinessReport[], baseline: Aba
 export declare function cmdReadiness(argv: string[], io: CliIo): number;
 export declare function cmdScaffold(argv: string[], io: CliIo): number;
 export declare function cmdOutline(argv: string[], io: CliIo): number;
+export declare function cmdCompare(argv: string[], io: CliIo): number;
 export declare function cmdExplain(argv: string[], io: CliIo): number;
 export declare function cmdReleased(argv: string[], io: CliIo): number;
 export declare function cmdRules(argv: string[], io: CliIo): number;
-export declare const USAGE = "abap-mcp \u2014 SAP ABAP analysis for AI agents (MCP server) and humans (CLI)\n\nUsage:\n  abap-mcp                       start the MCP server on stdio (for AI clients)\n  abap-mcp lint [paths\u2026]         lint files/dirs   [--abap-version v758|Cloud] [--preset style|full|syntax-only] [--json]\n  abap-mcp readiness [paths\u2026]    ABAP Cloud readiness diff   [--baseline v758] [--fail-below N] [--json]\n  abap-mcp scaffold \u2026            generate a RAP managed BO   (--entity --table --key [--fields n:type,\u2026] [--no-draft] [--provided-key] [--out DIR])\n  abap-mcp outline [paths\u2026]      classes/methods/forms structure   [--json]\n  abap-mcp released <names\u2026>     released-API status from the bundled SAP snapshot   [--type TABL|FUNC|\u2026] [--json]\n  abap-mcp explain <rule>        explain an abaplint rule\n  abap-mcp rules                 list rules   [--query q] [--tag Security]\n\nExit codes: 0 ok \u00B7 1 findings/validation failed \u00B7 2 usage error";
+export declare const USAGE = "abap-mcp \u2014 SAP ABAP analysis for AI agents (MCP server) and humans (CLI)\n\nUsage:\n  abap-mcp                       start the MCP server on stdio (for AI clients)\n  abap-mcp lint [paths\u2026]         lint files/dirs   [--abap-version v758|Cloud] [--preset style|full|syntax-only] [--focus Performance|Security|Styleguide] [--rules-file abaplint.json] [--json]\n  abap-mcp readiness [paths\u2026]    ABAP Cloud readiness diff, scored + graded A\u2013D   [--baseline v758] [--fail-below N] [--json]\n  abap-mcp compare BEFORE AFTER  what a rework changed: findings resolved/introduced, blocker/score/grade movement, structure   [--preset \u2026] [--focus \u2026] [--json]\n  abap-mcp scaffold \u2026            generate a RAP managed BO   (--entity --table --key [--fields n:type,\u2026] [--no-draft] [--provided-key] [--out DIR])\n  abap-mcp outline [paths\u2026]      classes/methods/forms structure   [--mermaid] [--json]\n  abap-mcp released <names\u2026>     released-API status from the bundled SAP snapshot   [--type TABL|FUNC|\u2026] [--json]\n  abap-mcp explain <rule>        explain an abaplint rule\n  abap-mcp rules                 list rules   [--query q] [--tag Security]\n\nExit codes: 0 ok \u00B7 1 findings/validation failed \u00B7 2 usage error";
 export declare function runCli(argv: string[], io: CliIo): number | null;

package/dist/cli-commands.js

@@ -7,9 +7,10 @@
  */
 import { readdirSync, readFileSync, realpathSync, statSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { basename, extname, join } from "node:path";
-import { ABAP_VERSIONS, MAX_FILES, runAbaplint } from "./abap/engine.js";
-import { outlineAbap } from "./abap/outline.js";
-import { checkCloudReadiness, SCOPE_NOTE } from "./abap/readiness.js";
+import { compareAbap } from "./abap/compare.js";
+import { ABAP_VERSIONS, FOCUS_TAGS, MAX_FILES, runAbaplint } from "./abap/engine.js";
+import { outlineAbap, outlineToMermaid } from "./abap/outline.js";
+import { checkCloudReadiness, gradeReadiness, SCOPE_NOTE } 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";
@@ -80,6 +81,31 @@ function asVersion(v, fallback) {
         return v;
     throw new Error(`Unknown ABAP version "${v}". Valid: ${ABAP_VERSIONS.join(", ")}`);
 }
+function asFocus(v) {
+    if (typeof v !== "string")
+        return undefined;
+    const match = FOCUS_TAGS.find((t) => t.toLowerCase() === v.toLowerCase());
+    if (match === undefined)
+        throw new Error(`Unknown focus "${v}". Valid: ${FOCUS_TAGS.join(", ")}`);
+    return match;
+}
+function asPreset(v) {
+    return v === "full" || v === "syntax-only" ? v : "style";
+}
+/** Read rule overrides from a JSON file — either a bare rules map or a full abaplint.json with a "rules" key. */
+function rulesFromFile(v) {
+    if (typeof v !== "string")
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(v, "utf8"));
+    }
+    catch (err) {
+        throw new Error(`Cannot read --rules-file ${v}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const inner = parsed["rules"];
+    return typeof inner === "object" && inner !== null ? inner : parsed;
+}
 function fmtFinding(f) {
     return `${f.file}:${f.line}:${f.column} [${f.severity}] ${f.rule}: ${f.message}`;
 }
@@ -91,11 +117,12 @@ export function cmdLint(argv, io) {
         return 2;
     }
     const version = asVersion(flags.get("abap-version"), "v758");
-    const presetRaw = flags.get("preset");
-    const preset = presetRaw === "full" || presetRaw === "syntax-only" ? presetRaw : "style";
+    const preset = asPreset(flags.get("preset"));
+    const focus = asFocus(flags.get("focus"));
+    const rules = rulesFromFile(flags.get("rules-file"));
     const all = [];
     for (const batch of chunk(files, MAX_FILES)) {
-        all.push(...runAbaplint(batch, { version, preset }).findings);
+        all.push(...runAbaplint(batch, { version, preset, focus, rules }).findings);
     }
     if (flags.has("json")) {
         io.out(JSON.stringify({ files: files.length, findings: all }, null, 2));
@@ -103,7 +130,7 @@ export function cmdLint(argv, io) {
     else {
         for (const f of all)
             io.out(fmtFinding(f));
-        io.out(`${all.length} finding(s) in ${files.length} file(s) [${preset} @ ${version}]`);
+        io.out(`${all.length} finding(s) in ${files.length} file(s) [${preset}${focus !== undefined ? `:${focus}` : ""} @ ${version}]`);
     }
     return all.some((f) => f.severity === "Error") ? 1 : 0;
 }
@@ -111,11 +138,13 @@ export function cmdLint(argv, io) {
 export function mergeReadiness(reports, baseline) {
     const categories = new Map();
     let blockers = 0;
+    let fileCount = 0;
     const broken = [];
     const releasedApiFindings = [];
     let snapshotDate = "";
     for (const r of reports) {
         blockers += r.cloudBlockerCount;
+        fileCount += r.fileCount;
         broken.push(...r.brokenAtBaseline);
         releasedApiFindings.push(...r.releasedApiFindings);
         snapshotDate = r.releasedApiSnapshotDate;
@@ -140,7 +169,9 @@ export function mergeReadiness(reports, baseline) {
     return {
         verdict,
         score,
+        grade: gradeReadiness(blockers, fileCount),
         cloudBlockerCount: blockers,
+        fileCount,
         categories: [...categories.values()].sort((a, b) => b.count - a.count),
         brokenAtBaseline: broken,
         releasedApiFindings,
@@ -163,7 +194,7 @@ export function cmdReadiness(argv, io) {
         io.out(JSON.stringify({ files: files.length, ...merged }, null, 2));
     }
     else {
-        io.out(`ABAP Cloud readiness: ${merged.verdict} (score ${merged.score})`);
+        io.out(`ABAP Cloud readiness: ${merged.verdict} (score ${merged.score}, grade ${merged.grade})`);
         io.out(`${merged.cloudBlockerCount} cloud blocker(s) across ${files.length} file(s)`);
         for (const c of merged.categories)
             io.out(`  ${c.category.padEnd(18)} ${String(c.count).padStart(4)}  ${c.label}`);
@@ -252,6 +283,10 @@ export function cmdOutline(argv, io) {
         return 2;
     }
     const outlines = chunk(files, MAX_FILES).flatMap((b) => outlineAbap(b));
+    if (flags.has("mermaid")) {
+        io.out(outlineToMermaid(outlines));
+        return 0;
+    }
     if (flags.has("json")) {
         io.out(JSON.stringify(outlines, null, 2));
         return 0;
@@ -271,6 +306,57 @@ export function cmdOutline(argv, io) {
     }
     return 0;
 }
+export function cmdCompare(argv, io) {
+    const { flags, rest } = parseFlags(argv);
+    if (rest.length !== 2) {
+        io.err("Usage: abap-mcp compare BEFORE_PATH AFTER_PATH   [--abap-version v758|Cloud] [--preset style|full|syntax-only] [--focus Performance|Security|Styleguide] [--rules-file abaplint.json] [--json]");
+        return 2;
+    }
+    const before = collectFiles([rest[0]], io);
+    const after = collectFiles([rest[1]], io);
+    if (before.length === 0 || after.length === 0) {
+        io.err("No ABAP sources found on one side.");
+        return 2;
+    }
+    if (before.length > MAX_FILES || after.length > MAX_FILES) {
+        io.err(`compare is object-level: at most ${MAX_FILES} files per side — narrow each path to the object(s) under review.`);
+        return 2;
+    }
+    const report = compareAbap(before, after, {
+        version: asVersion(flags.get("abap-version"), "v758"),
+        preset: asPreset(flags.get("preset")),
+        focus: asFocus(flags.get("focus")),
+        rules: rulesFromFile(flags.get("rules-file")),
+    });
+    if (flags.has("json")) {
+        io.out(JSON.stringify(report, null, 2));
+    }
+    else {
+        io.out(`lint: ${report.introduced.length} introduced, ${report.resolved.length} resolved, ${report.unchangedCount} unchanged`);
+        for (const f of report.introduced)
+            io.out(`  + ${fmtFinding(f)}`);
+        for (const f of report.resolved)
+            io.out(`  - ${fmtFinding(f)}`);
+        io.out(`readiness: blockers ${report.before.cloudBlockerCount} → ${report.after.cloudBlockerCount}, ` +
+            `score ${report.before.score} → ${report.after.score}, grade ${report.before.grade} → ${report.after.grade}`);
+        const oc = report.outlineChanges;
+        const structural = [
+            ...oc.classesAdded.map((s) => `+ class ${s}`),
+            ...oc.classesRemoved.map((s) => `- class ${s}`),
+            ...oc.methodsAdded.map((s) => `+ method ${s}`),
+            ...oc.methodsRemoved.map((s) => `- method ${s}`),
+            ...oc.formsAdded.map((s) => `+ form ${s}`),
+            ...oc.formsRemoved.map((s) => `- form ${s}`),
+        ];
+        if (structural.length > 0) {
+            io.out("structure:");
+            for (const s of structural)
+                io.out(`  ${s}`);
+        }
+    }
+    // Regression gate: new findings or more cloud blockers fail the rework.
+    return report.introduced.length > 0 || report.after.cloudBlockerCount > report.before.cloudBlockerCount ? 1 : 0;
+}
 export function cmdExplain(argv, io) {
     const { rest } = parseFlags(argv);
     const key = rest[0];
@@ -320,10 +406,11 @@ export const USAGE = `abap-mcp — SAP ABAP analysis for AI agents (MCP server)
 
 Usage:
   abap-mcp                       start the MCP server on stdio (for AI clients)
-  abap-mcp lint [paths…]         lint files/dirs   [--abap-version v758|Cloud] [--preset style|full|syntax-only] [--json]
-  abap-mcp readiness [paths…]    ABAP Cloud readiness diff   [--baseline v758] [--fail-below N] [--json]
+  abap-mcp lint [paths…]         lint files/dirs   [--abap-version v758|Cloud] [--preset style|full|syntax-only] [--focus Performance|Security|Styleguide] [--rules-file abaplint.json] [--json]
+  abap-mcp readiness [paths…]    ABAP Cloud readiness diff, scored + graded A–D   [--baseline v758] [--fail-below N] [--json]
+  abap-mcp compare BEFORE AFTER  what a rework changed: findings resolved/introduced, blocker/score/grade movement, structure   [--preset …] [--focus …] [--json]
   abap-mcp scaffold …            generate a RAP managed BO   (--entity --table --key [--fields n:type,…] [--no-draft] [--provided-key] [--out DIR])
-  abap-mcp outline [paths…]      classes/methods/forms structure   [--json]
+  abap-mcp outline [paths…]      classes/methods/forms structure   [--mermaid] [--json]
   abap-mcp released <names…>     released-API status from the bundled SAP snapshot   [--type TABL|FUNC|…] [--json]
   abap-mcp explain <rule>        explain an abaplint rule
   abap-mcp rules                 list rules   [--query q] [--tag Security]
@@ -339,6 +426,8 @@ export function runCli(argv, io) {
             return cmdLint(rest, io);
         case "readiness":
             return cmdReadiness(rest, io);
+        case "compare":
+            return cmdCompare(rest, io);
         case "scaffold":
             return cmdScaffold(rest, io);
         case "outline":

package/dist/index.d.ts

@@ -1,17 +1,20 @@
 /** Library surface — embed the tools or the server in your own process. */
 export { buildServer, SERVER_NAME, SERVER_VERSION } from "./server.js";
 export { ALL_TOOLS } from "./abap.tools.js";
-export { runAbaplint, inferFilename, ABAP_VERSIONS } from "./abap/engine.js";
-export type { AbapSource, AbapVersion, Finding } from "./abap/engine.js";
-export { checkCloudReadiness } from "./abap/readiness.js";
-export type { ReadinessReport, ReleasedApiFinding } from "./abap/readiness.js";
+export { runAbaplint, inferFilename, ABAP_VERSIONS, FOCUS_TAGS } from "./abap/engine.js";
+export type { AbapSource, AbapVersion, Finding, FocusTag } from "./abap/engine.js";
+export { checkCloudReadiness, gradeReadiness } from "./abap/readiness.js";
+export type { ReadinessReport, ReadinessGrade, ReleasedApiFinding } from "./abap/readiness.js";
+export { compareAbap } from "./abap/compare.js";
+export type { CompareReport, CompareOptions, CompareSide, OutlineChanges } from "./abap/compare.js";
 export { lookupReleased, suggestSuccessor, RELEASED_API_SNAPSHOT } from "./abap/released.js";
 export type { ReleasedLookup, ReleasedState } from "./abap/released.js";
 export { scaffoldRapBo, snakeToCamel } from "./abap/scaffold.js";
 export type { ScaffoldOptions, ScaffoldResult } from "./abap/scaffold.js";
 export { listRules, explainRule } from "./abap/rules.js";
 export { formatAbap } from "./abap/formatter.js";
-export { outlineAbap } from "./abap/outline.js";
+export { outlineAbap, outlineToMermaid } from "./abap/outline.js";
+export type { FileOutline, ClassOutline, MethodOutline } from "./abap/outline.js";
 export { defineTool, registerTool, registerTools } from "./tool.js";
 export type { ToolSpec, AnyToolSpec, ToolExample } from "./tool.js";
 export { McpToolError, invalidInput, notFound } from "./errors.js";

package/dist/index.js

@@ -1,12 +1,13 @@
 /** Library surface — embed the tools or the server in your own process. */
 export { buildServer, SERVER_NAME, SERVER_VERSION } from "./server.js";
 export { ALL_TOOLS } from "./abap.tools.js";
-export { runAbaplint, inferFilename, ABAP_VERSIONS } from "./abap/engine.js";
-export { checkCloudReadiness } from "./abap/readiness.js";
+export { runAbaplint, inferFilename, ABAP_VERSIONS, FOCUS_TAGS } from "./abap/engine.js";
+export { checkCloudReadiness, gradeReadiness } from "./abap/readiness.js";
+export { compareAbap } from "./abap/compare.js";
 export { lookupReleased, suggestSuccessor, RELEASED_API_SNAPSHOT } from "./abap/released.js";
 export { scaffoldRapBo, snakeToCamel } from "./abap/scaffold.js";
 export { listRules, explainRule } from "./abap/rules.js";
 export { formatAbap } from "./abap/formatter.js";
-export { outlineAbap } from "./abap/outline.js";
+export { outlineAbap, outlineToMermaid } from "./abap/outline.js";
 export { defineTool, registerTool, registerTools } from "./tool.js";
 export { McpToolError, invalidInput, notFound } from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abap-mcp",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "mcpName": "io.github.palimkarakshay/abap-mcp",
   "description": "MCP server for SAP ABAP: offline static analysis (abaplint), ABAP Cloud / Clean Core readiness checks, and RAP scaffolding — no SAP system or credentials required.",
   "license": "MIT",
@@ -43,13 +43,13 @@
     "start": "node dist/cli.js"
   },
   "dependencies": {
-    "@abaplint/core": "^2.119.25",
+    "@abaplint/core": "^2.119.27",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
-    "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "@types/node": "^25.9.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
   }
 }