mcp-server-sfmc 1.9.1 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # mcp-server-sfmc
 
-MCP server providing Salesforce Marketing Cloud language intelligence — AMPscript, SSJS, and GTL — as Model Context Protocol tools, resources, and prompts for AI-assisted development and code review. Ships two searchable doc indexes: **MCE help** (Salesforce Help for Marketing Cloud Engagement administration and setup) and **MCN developer docs** (Marketing Cloud Next REST API and developer reference). Includes full **Marketing Cloud Next (MCN) platform awareness**: auto-detects whether a project targets MCE or MCN, restricts completions and validation to MCN-supported functions, flags SSJS as unsupported in MCN, surfaces MCN behavioral differences in hover and diagnostics, and provides a **migration toolkit** to analyze and rewrite code for MCN.
+MCP server providing Salesforce Marketing Cloud language intelligence — AMPscript, SSJS, GTL, and **Marketing Cloud Next (MCN) Handlebars** — as Model Context Protocol tools, resources, and prompts for AI-assisted development and code review. Ships two searchable doc indexes: **MCE help** (Salesforce Help for Marketing Cloud Engagement administration and setup) and **MCN developer docs** (Marketing Cloud Next REST API and developer reference). Includes full **Marketing Cloud Next (MCN) platform awareness**: auto-detects whether a project targets MCE or MCN, restricts completions and validation to MCN-supported functions, flags SSJS as unsupported in MCN, surfaces MCN behavioral differences in hover and diagnostics, validates MCN Handlebars templates, and provides a **migration toolkit** to analyze and rewrite code for MCN — including AMPscript ↔ Handlebars and SSJS → Handlebars conversion.
 
 Built on [sfmc-language-lsp](https://github.com/JoernBerkefeld/sfmc-language-lsp), the same engine that powers the [SFMC Language Service VS Code extension](https://marketplace.visualstudio.com/items?itemName=joernberkefeld.sfmc-language).
 
@@ -41,7 +41,7 @@ Ready-to-copy workflows (GitHub Actions, GitLab CI, Jenkins, Azure Pipelines, Bi
 
 | Feature                        | Details                                                                                                                                                                                        |
 | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Validation**                 | Syntax errors, unknown functions, arity mismatches, unsupported SSJS syntax; `target: 'next'` flags MCN-incompatible functions and all SSJS                                                    |
+| **Validation**                 | Syntax errors, unknown functions, arity mismatches, unsupported SSJS syntax; `target: 'next'` flags MCN-incompatible functions and all SSJS; `validate_handlebars` checks MCN Handlebars helper names, arity, block balance, and unsupported constructs |
 | **Lookup**                     | Full function signatures, parameters, return types, MCN compatibility badge (API version), behavioral notes, and examples                                                                      |
 | **PR review**                  | Diff-aware review tool that surfaces issues in the exact lines that changed                                                                                                                    |
 | **Fix suggestions**            | Concrete, compilable replacement code; `target: 'next'` includes MCN platform issues                                                                                                           |
@@ -50,8 +50,10 @@ Ready-to-copy workflows (GitHub Actions, GitLab CI, Jenkins, Azure Pipelines, Bi
 | **MCN compatibility analysis** | `check_mcn_compatibility` analyzes files for MCN readiness — per-function classification (supported / needs review / not supported), SSJS block migration difficulty, and an executive summary |
 | **MCN migration**              | `rewrite_for_mcn` (tool + prompt) deterministically rewrites AMPscript and converts convertible SSJS to AMPscript for MCN, then applies AI reasoning to remaining manual-rewrite sections      |
 | **Code conversion**            | `convertSsjsToAmpscript` and `convertAmpscriptToSsjs` (tool + prompt hybrid) — rule-based conversion with AI-enhanced handling of flagged sections                                             |
-| **Prompts**                    | Guided prompts for writing AMPscript/SSJS (with MCN constraints), reviewing code, converting between the two, and rewriting for MCN                                                            |
-| **Resources**                  | Full function catalogs, keyword list, unsupported ES6+ syntax list                                                                                                                             |
+| **MCN Handlebars**             | `lookup_handlebars_helper`, `list_handlebars_helpers`, `get_handlebars_completions`, and `write_handlebars` (authoring) backed by the `handlebars-data` catalog                                |
+| **Handlebars conversion**      | `convertAmpscriptToHandlebars`, `convertHandlebarsToAmpscript`, and `convertSsjsToHandlebars` (tool + prompt hybrid) — data-driven from `ampscript-data` `handlebarsEquivalent` / `mcnHandlebarsGap` |
+| **Prompts**                    | Guided prompts for writing AMPscript/SSJS/Handlebars (with MCN constraints), reviewing code, converting between languages, and rewriting for MCN                                               |
+| **Resources**                  | Full function catalogs, keyword list, unsupported ES6+ syntax list, MCN Handlebars helper and binding catalogs                                                                                 |
 | **Help search**                | `search_help` (unified, auto-detects MCE vs MCN from project root); `search_mce_help` (MCE help, 7 product scopes); `search_mcn_help` (MCN developer API reference)                            |
 
 ## Connecting AI clients
@@ -156,6 +158,14 @@ Then replace `"command": "npx", "args": ["-y", "mcp-server-sfmc@latest"]` with:
 | `rewrite_for_mcn`           | Deterministic MCN rewrite engine: fixes `.NET → Java` format strings, removes `StringToDate` wrappers, converts convertible SSJS to AMPscript, marks unsupported functions, annotates the rest as `MANUAL_REWRITE_REQUIRED`. **Prefer the `rewrite_for_mcn` prompt** for interactive use — it calls this tool first, then applies AI reasoning to the flagged sections. Use the tool directly only for structured JSON output in pipelines. |
 | `convertSsjsToAmpscript`    | Rule-based SSJS → AMPscript conversion engine: `Platform.Function.*` → AMPscript equivalents, variable/request access, control flow. Flags JS-native constructs as `MANUAL_REWRITE_REQUIRED`. **Prefer the `convertSsjsToAmpscript` prompt** for interactive use.                                                                                                                                                                           |
 | `convertAmpscriptToSsjs`    | Rule-based AMPscript → SSJS conversion engine: variables, control flow, function calls. Flags AMPscript-only constructs as `MANUAL_REWRITE_REQUIRED`. **Prefer the `convertAmpscriptToSsjs` prompt** for interactive use.                                                                                                                                                                                                                   |
+| `validate_handlebars`        | Validate MCN Handlebars template code — helper names, arity, block balance, and unsupported constructs (partials, decorators, built-in helpers absent from the locked-down MCN engine).                                                                                                                                                                                                                                                     |
+| `lookup_handlebars_helper`   | Signature, parameters, description, origin, and MCN API version for a single MCN Handlebars helper (case-insensitive).                                                                                                                                                                                                                                                                                                                      |
+| `list_handlebars_helpers`    | List all MCN Handlebars helpers, optionally filtered by `category` and/or `origin` (`handlebars-builtin`, `mcn-helper`, `mcn-platform`).                                                                                                                                                                                                                                                                                                    |
+| `get_handlebars_completions` | List MCN Handlebars helper completions, optionally filtered by prefix.                                                                                                                                                                                                                                                                                                                                                                      |
+| `convertAmpscriptToHandlebars` | Rule-based AMPscript → MCN Handlebars conversion. Maps functions to helpers where an equivalent exists; flags unsupported functions and runtime gaps as `MANUAL_REWRITE_REQUIRED`. **Prefer the `convertAmpscriptToHandlebars` prompt** for interactive use.                                                                                                                                                                              |
+| `convertHandlebarsToAmpscript` | Rule-based MCN Handlebars → AMPscript conversion. Maps helpers and bindings back to AMPscript; flags block helpers as `MANUAL_REWRITE_REQUIRED`. **Prefer the `convertHandlebarsToAmpscript` prompt** for interactive use.                                                                                                                                                                                                               |
+| `convertSsjsToHandlebars`    | Transitive SSJS → AMPscript → MCN Handlebars conversion. Conservatively flags imperative SSJS for manual rewrite. **Prefer the `convertSsjsToHandlebars` prompt** for interactive use.                                                                                                                                                                                                                                                      |
+| `write_handlebars`           | Validate an MCN Handlebars-in-HTML draft against the helper catalog. **Prefer the `writeHandlebars` prompt** for authoring.                                                                                                                                                                                                                                                                                                                 |
 | `search_help`               | **Unified help search** — auto-detects the platform from `projectRoot` and routes to the right doc index. MCN projects search both the developer API reference and MCN admin docs. Pass `target` to override detection.                                                                                                                                                                                                                     |
 | `search_mce_help`           | Search bundled Marketing Cloud Engagement setup/ops help; use `product_focus` to target Engagement vs Next                                                                                                                                                                                                                                                                                                                                  |
 | `search_mcn_help`           | Search bundled Marketing Cloud Next developer API documentation (objects, flows, segments, REST/SOAP APIs, AMPscript behavior in MCN)                                                                                                                                                                                                                                                                                                       |
@@ -168,6 +178,8 @@ Then replace `"command": "npx", "args": ["-y", "mcp-server-sfmc@latest"]` with:
 | `sfmc://ssjs/functions`          | Full SSJS function catalog                                                                   |
 | `sfmc://ampscript/keywords`      | All AMPscript keywords                                                                       |
 | `sfmc://ssjs/unsupported-syntax` | ES6+ features not supported in SFMC SSJS                                                     |
+| `sfmc://handlebars/helpers`      | Full MCN Handlebars helper catalog with signatures, origin, and MCN API version              |
+| `sfmc://handlebars/bindings`     | MCN Handlebars data bindings (context variables available in templates)                      |
 | `sfmc://mce/product-context`     | How **Marketing Cloud Engagement** differs from **Marketing Cloud Next** (when to use which) |
 | `sfmc://mce/help-index`          | List of bundled MCE help files and section counts per product scope                          |
 | `sfmc://mcn/help-index`          | List of bundled MCN developer API doc files and chunk counts                                 |
@@ -184,6 +196,10 @@ Access via `/mcp.sfmc.writeAmpscript` etc. in VS Code, or via the prompts API:
 | `rewrite_for_mcn`        | **Primary interface for MCN migration.** Internally calls the `rewrite_for_mcn` tool for all deterministic rewrites, then applies AI reasoning to every `MANUAL_REWRITE_REQUIRED` section — producing a single fully migrated code block with a prose changelog. You always get both the rule-based pass and the AI pass in one step. |
 | `convertSsjsToAmpscript` | **Primary interface for SSJS → AMPscript conversion.** Internally calls the `convertSsjsToAmpscript` tool for rule-based conversion, then AI-reasons over any sections the rules could not handle.                                                                                                                                    |
 | `convertAmpscriptToSsjs` | **Primary interface for AMPscript → SSJS conversion.** Internally calls the `convertAmpscriptToSsjs` tool for rule-based conversion, then applies AI reasoning to flagged AMPscript-only constructs.                                                                                                                                  |
+| `writeHandlebars`        | Generate MCN Handlebars-in-HTML for a described task, constrained to the locked-down MCN helper catalog. Validates the draft against `handlebars-data` and reports unsupported constructs.                                                                                                                                            |
+| `convertAmpscriptToHandlebars` | **Primary interface for AMPscript → MCN Handlebars conversion.** Internally calls the `convertAmpscriptToHandlebars` tool for rule-based conversion, then AI-reasons over functions with no Handlebars equivalent (runtime gaps and unsupported functions).                                                                     |
+| `convertHandlebarsToAmpscript` | **Primary interface for MCN Handlebars → AMPscript conversion.** Internally calls the `convertHandlebarsToAmpscript` tool for rule-based conversion, then AI-reasons over block helpers and constructs the rules could not handle.                                                                                              |
+| `convertSsjsToHandlebars`      | **Primary interface for SSJS → MCN Handlebars conversion.** Transitive (SSJS → AMPscript → Handlebars); calls the `convertSsjsToHandlebars` tool, then applies AI reasoning to imperative SSJS flagged for manual rewrite.                                                                                                       |
 | `answerMceHowTo`         | Guided prompt for admin/setup questions — searches bundled help and keeps Engagement vs Next explicit                                                                                                                                                                                                                                 |
 
 ## Migrating code to Marketing Cloud Next
@@ -243,6 +259,34 @@ The same hybrid pattern applies to `convertSsjsToAmpscript` and `convertAmpscrip
 
 Functions that depend on CloudPages context (`CloudPagesURL`, `RequestParameter`, `QueryParameter`, `Redirect`, `MicrositeURL`) have no equivalent in Marketing Cloud Next. `check_mcn_compatibility` and `rewrite_for_mcn` flag these as **Not migratable** immediately.
 
+## MCN Handlebars
+
+Marketing Cloud Next embeds a **locked-down Handlebars** templating layer (Handlebars.Net) alongside AMPscript. The server exposes the full helper catalog and conversion tooling, all data-driven from [`handlebars-data`](https://www.npmjs.com/package/handlebars-data) and the `handlebarsEquivalent` / `mcnHandlebarsGap` fields in [`ampscript-data`](https://www.npmjs.com/package/ampscript-data) — nothing is hand-maintained.
+
+### Authoring & lookup
+
+```
+1. list_handlebars_helpers       →  browse the catalog (filter by category / origin)
+2. lookup_handlebars_helper      →  signature, parameters, origin, MCN API version
+3. get_handlebars_completions    →  prefix-filtered completions
+4. writeHandlebars prompt        →  generate Handlebars-in-HTML, validated against the catalog
+5. validate_handlebars           →  helper names, arity, block balance, unsupported constructs
+```
+
+`validate_handlebars` rejects constructs the MCN engine does not implement — partials (`{{> name}}`), decorators (`{{#* ...}}`), and built-in helpers absent from the locked-down runtime.
+
+### Conversion categories
+
+AMPscript → Handlebars conversion classifies every function from `ampscript-data`:
+
+| Category | Condition (in `ampscript-data`)                       | Output                                                            |
+| -------- | ----------------------------------------------------- | ----------------------------------------------------------------- |
+| **A**    | `handlebarsEquivalent` is a helper name               | Mapped to the canonical MCN Handlebars helper                     |
+| **B**    | No Handlebars counterpart                             | `{{!-- MANUAL_REWRITE_REQUIRED: … no Handlebars equivalent --}}`  |
+| **C**    | `mcnHandlebarsGap: true` (MCN-supported, no helper yet) | `{{!-- MANUAL_REWRITE_REQUIRED: … (runtime gap) --}}` (distinct note) |
+
+The Category C note is intentionally distinct from Category B so consumers can tell a *runtime gap* (function works in MCN AMPscript but has no Handlebars helper) apart from a function with no MCN counterpart at all. `convertSsjsToHandlebars` is transitive (SSJS → AMPscript → Handlebars) and conservatively flags imperative SSJS for manual rewrite.
+
 ## Writing effective prompts
 
 ### Automatic tool use
@@ -262,6 +306,8 @@ Clients that honour the MCP `instructions` field (Cursor, Claude Desktop, GitHub
 | Check if code is MCN-ready                   | Use `check_mcn_compatibility` with your file contents.                                                                                                                                                                                     |
 | Migrate code to Marketing Cloud Next         | Use the `rewrite_for_mcn` **prompt** — it calls the tool internally for deterministic rewrites, then applies AI reasoning to any remaining manual sections. Use the tool directly only when you need structured JSON output in a pipeline. |
 | Convert SSJS ↔ AMPscript                     | Use the `convertSsjsToAmpscript` or `convertAmpscriptToSsjs` **prompt** — same hybrid pattern: tool runs first, AI handles what the rules couldn't.                                                                                        |
+| Write or validate MCN Handlebars             | Use the `writeHandlebars` prompt to author, or `validate_handlebars` to check existing template code. Look helpers up with `lookup_handlebars_helper` / `list_handlebars_helpers`.                                                          |
+| Convert AMPscript ↔ Handlebars (or SSJS → Handlebars) | Use the `convertAmpscriptToHandlebars`, `convertHandlebarsToAmpscript`, or `convertSsjsToHandlebars` **prompt** — same hybrid pattern: tool runs first, AI handles what the rules couldn't.                                       |
 | Review a code diff                           | Use the `reviewSfmcCode` prompt or mention "review the following diff".                                                                                                                                                                    |
 
 ### Copy-paste prompt templates

package/dist/conversion-rules.d.ts

@@ -34,6 +34,31 @@ export declare const PLATFORM_FUNCTION_TO_AMP: Readonly<Record<string, string>>;
  * PLATFORM_FUNCTION_TO_AMP at module load time.
  */
 export declare const AMP_TO_PLATFORM_FUNCTION: Readonly<Record<string, string>>;
+/**
+ * Maps an AMPscript function name (lowercase) to the canonical MCN Handlebars
+ * helper name it converts to. Built at module load time from ampscript-data's
+ * `handlebarsEquivalent` field — always in sync with the installed
+ * ampscript-data version, never hand-edited (`mcp-conversion-rules-sync.mdc`).
+ *
+ * Only Category A functions (non-null string `handlebarsEquivalent`) are
+ * included. The stored value is the bare helper name; the canonical casing is
+ * resolved through `handlebars-data` so emitted `{{helper}}` calls match the
+ * catalog exactly.
+ */
+export declare const AMP_TO_HANDLEBARS: Readonly<Record<string, string>>;
+/**
+ * Maps a canonical MCN Handlebars helper name (lowercase) to its AMPscript
+ * function name. Inverted from AMP_TO_HANDLEBARS at module load time. Used by
+ * convertHandlebarsToAmpscript.
+ */
+export declare const HANDLEBARS_TO_AMP: Readonly<Record<string, string>>;
+/**
+ * Set of AMPscript function names (lowercase) flagged `mcnHandlebarsGap: true`
+ * in ampscript-data (Category C). These are documented as MCN-supported but
+ * currently fail at runtime and have no Handlebars helper — converting them
+ * must emit a MANUAL_REWRITE marker distinct from Category B (no counterpart).
+ */
+export declare const AMP_MCN_HANDLEBARS_GAP: ReadonlySet<string>;
 /**
  * Maps an AMPscript function name (lowercase) to a native JavaScript rewrite
  * hint comment. Checked BEFORE the TreatAsContent polyfill fallback in
@@ -109,6 +134,53 @@ export declare function ampscriptToSsjs(code: string): ConversionResult;
  * @returns {string} Expression with `@` prefixes removed.
  */
 export declare function stripAmpVars(expr: string): string;
+/**
+ * Distinct MANUAL_REWRITE note for Category C functions (`mcnHandlebarsGap`).
+ * Must be visibly different from the Category B note so consumers can tell a
+ * documented-but-broken function apart from one with no counterpart at all.
+ */
+export declare const HBS_GAP_NOTE = "documented as supported in Marketing Cloud Next but currently fails at runtime \u2014 no Handlebars helper exists yet";
+/**
+ * Convert AMPscript to MCN Handlebars using deterministic, data-driven rules.
+ *
+ * Inline expressions (`%%=Fn(args)=%%`, `%%=v(@x)=%%`, `%%var%%`) are mapped via
+ * the three conversion categories built from ampscript-data's
+ * `handlebarsEquivalent` / `mcnHandlebarsGap` fields:
+ * - **A** — mapped helper → `{{helper …}}`
+ * - **B** — no counterpart → `{{!-- MANUAL_REWRITE_REQUIRED … --}}`
+ * - **C** — `mcnHandlebarsGap` → `{{!-- MANUAL_REWRITE_REQUIRED … (distinct note) --}}`
+ *
+ * Procedural AMPscript blocks (`%%[ … ]%%`, `SET`/`VAR`/`IF`/`FOR`) have no
+ * Handlebars counterpart (Handlebars cannot assign variables or run imperative
+ * control flow) and are flagged MANUAL_REWRITE_REQUIRED.
+ * @param code - AMPscript source code (may include HTML context).
+ * @returns {ConversionResult} Converted Handlebars, change log, and flagged sections.
+ */
+export declare function ampscriptToHandlebars(code: string): ConversionResult;
+/**
+ * Convert MCN Handlebars to AMPscript using deterministic, data-driven rules.
+ *
+ * Inline helper calls (`{{helper args}}`) whose helper maps back to an AMPscript
+ * function (via HANDLEBARS_TO_AMP) become `%%=Fn(args)=%%`; bare variables
+ * (`{{name}}`) become `%%=v(@name)=%%`. Block helpers (`{{#each}}`…), partials
+ * (`{{> …}}`), dotted binding paths, and unknown helpers are flagged
+ * MANUAL_REWRITE_REQUIRED.
+ * @param code - Handlebars source code (may include HTML context).
+ * @returns {ConversionResult} Converted AMPscript, change log, and flagged sections.
+ */
+export declare function handlebarsToAmpscript(code: string): ConversionResult;
+/**
+ * Convert SSJS to MCN Handlebars deterministically via a two-step chain:
+ * SSJS → AMPscript (`ssjsToAmpscript`) → Handlebars (`ampscriptToHandlebars`).
+ *
+ * Because Handlebars is declarative, most imperative SSJS has no Handlebars
+ * counterpart and is conservatively flagged MANUAL_REWRITE_REQUIRED; inline
+ * `Platform.Function.X(…)` calls that map through AMPscript to a Handlebars
+ * helper are converted.
+ * @param code - SSJS source code (may include `<script runat="server">` tags).
+ * @returns {ConversionResult} Converted Handlebars, combined change log, and flagged sections.
+ */
+export declare function ssjsToHandlebars(code: string): ConversionResult;
 export interface McnRewriteOptions {
     /** Function to check if an AMPscript function is MCN-supported */
     isMcnSupportedFn: (name: string) => boolean;

package/dist/conversion-rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conversion-rules.d.ts","sourceRoot":"","sources":["../src/conversion-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,eAAe,EAAE,cAAc,EAAE,CAAC;CACrC;AAQD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMrE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKrE,CAAC;AAiBF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAuBhE,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,EAAE,aAAa,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAG9E,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,CAezD,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CASxD,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAmC3F,CAAC;AAMF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CA8K9D;AAsBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CA+J9D;AAwPD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAMD,MAAM,WAAW,iBAAiB;IAC9B,kEAAkE;IAClE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C,0DAA0D;IAC1D,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CAClD;AAED,MAAM,WAAW,gBAAgB;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,kBAAkB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E,UAAU,EAAE,OAAO,GAAG,OAAO,GAAG,aAAa,GAAG,gBAAgB,CAAC;IACjE,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAiL3F;AAMD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcjD;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAQjE"}
+{"version":3,"file":"conversion-rules.d.ts","sourceRoot":"","sources":["../src/conversion-rules.ts"],"names":[],"mappings":"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"}

package/dist/conversion-rules.js

@@ -37,6 +37,48 @@ export const AMP_TO_PLATFORM_FUNCTION = Object.fromEntries(PLATFORM_FUNCTIONS.fi
  */
 const SSJS_ONLY_FUNCTIONS = new Set(PLATFORM_FUNCTIONS.filter((f) => f.ampscriptEquivalent === null).map((f) => f.name.toLowerCase()));
 // ---------------------------------------------------------------------------
+// Dynamic AMPscript ↔ MCN Handlebars maps (built from ampscript-data at load time)
+// ---------------------------------------------------------------------------
+import { FUNCTIONS as AMPSCRIPT_FUNCTIONS } from 'ampscript-data';
+import { getHelper as getHandlebarsHelper } from 'handlebars-data';
+/**
+ * Maps an AMPscript function name (lowercase) to the canonical MCN Handlebars
+ * helper name it converts to. Built at module load time from ampscript-data's
+ * `handlebarsEquivalent` field — always in sync with the installed
+ * ampscript-data version, never hand-edited (`mcp-conversion-rules-sync.mdc`).
+ *
+ * Only Category A functions (non-null string `handlebarsEquivalent`) are
+ * included. The stored value is the bare helper name; the canonical casing is
+ * resolved through `handlebars-data` so emitted `{{helper}}` calls match the
+ * catalog exactly.
+ */
+export const AMP_TO_HANDLEBARS = Object.fromEntries(AMPSCRIPT_FUNCTIONS.filter((f) => typeof f.handlebarsEquivalent === 'string' && f.handlebarsEquivalent.length > 0).map((f) => {
+    const canonical = getHandlebarsHelper(f.handlebarsEquivalent);
+    return [
+        f.name.toLowerCase(),
+        canonical ? canonical.name : f.handlebarsEquivalent,
+    ];
+}));
+/**
+ * Maps a canonical MCN Handlebars helper name (lowercase) to its AMPscript
+ * function name. Inverted from AMP_TO_HANDLEBARS at module load time. Used by
+ * convertHandlebarsToAmpscript.
+ */
+export const HANDLEBARS_TO_AMP = Object.fromEntries(AMPSCRIPT_FUNCTIONS.filter((f) => typeof f.handlebarsEquivalent === 'string' && f.handlebarsEquivalent.length > 0).map((f) => {
+    const canonical = getHandlebarsHelper(f.handlebarsEquivalent);
+    return [
+        (canonical ? canonical.name : f.handlebarsEquivalent).toLowerCase(),
+        f.name,
+    ];
+}));
+/**
+ * Set of AMPscript function names (lowercase) flagged `mcnHandlebarsGap: true`
+ * in ampscript-data (Category C). These are documented as MCN-supported but
+ * currently fail at runtime and have no Handlebars helper — converting them
+ * must emit a MANUAL_REWRITE marker distinct from Category B (no counterpart).
+ */
+export const AMP_MCN_HANDLEBARS_GAP = new Set(AMPSCRIPT_FUNCTIONS.filter((f) => f.mcnHandlebarsGap === true).map((f) => f.name.toLowerCase()));
+// ---------------------------------------------------------------------------
 // AMP_NATIVE_JS_HINTS: AMPscript-only functions with clean native JS rewrites
 // ---------------------------------------------------------------------------
 /**
@@ -698,6 +740,337 @@ function ampCondToSsjs(cond) {
 export function stripAmpVars(expr) {
     return expr.replaceAll(/@(\w+)/g, '$1');
 }
+// ---------------------------------------------------------------------------
+// AMPscript ↔ MCN Handlebars conversion
+// ---------------------------------------------------------------------------
+/**
+ * Distinct MANUAL_REWRITE note for Category C functions (`mcnHandlebarsGap`).
+ * Must be visibly different from the Category B note so consumers can tell a
+ * documented-but-broken function apart from one with no counterpart at all.
+ */
+export const HBS_GAP_NOTE = 'documented as supported in Marketing Cloud Next but currently fails at runtime — no Handlebars helper exists yet';
+/**
+ * Split a function-argument string into top-level comma-separated arguments,
+ * respecting nested parens/brackets and quoted strings. Returns an empty array
+ * for an empty/whitespace-only string.
+ * @param argsStr - The argument string (contents between the outer parens).
+ * @returns {string[]} Trimmed top-level arguments.
+ */
+function splitArgs(argsStr) {
+    if (!argsStr.trim())
+        return [];
+    const args = [];
+    let depth = 0;
+    let current = '';
+    let quote = null;
+    for (const ch of argsStr) {
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        switch (ch) {
+            case '"':
+            case "'": {
+                quote = ch;
+                current += ch;
+                break;
+            }
+            case '(':
+            case '[': {
+                depth++;
+                current += ch;
+                break;
+            }
+            case ')':
+            case ']': {
+                depth--;
+                current += ch;
+                break;
+            }
+            default: {
+                if (ch === ',' && depth === 0) {
+                    args.push(current.trim());
+                    current = '';
+                }
+                else {
+                    current += ch;
+                }
+            }
+        }
+    }
+    if (current.trim())
+        args.push(current.trim());
+    return args;
+}
+/**
+ * Convert a single AMPscript call argument to its Handlebars form: string and
+ * numeric literals pass through unchanged; `@var` references lose the `@`.
+ * @param arg - A single AMPscript argument.
+ * @returns {string} The Handlebars argument.
+ */
+function ampArgToHbs(arg) {
+    const t = arg.trim();
+    if (/^["']/.test(t))
+        return t;
+    return stripAmpVars(t);
+}
+/**
+ * Convert a single Handlebars argument to its AMPscript form: string/number/
+ * boolean literals pass through; bare identifiers become `@var` references;
+ * dotted paths are returned unchanged (caller decides how to flag them).
+ * @param arg - A single Handlebars argument.
+ * @returns {string} The AMPscript argument.
+ */
+function hbsArgToAmp(arg) {
+    const t = arg.trim();
+    if (/^["']/.test(t))
+        return t;
+    if (/^-?\d/.test(t))
+        return t;
+    if (/^(true|false|null)$/i.test(t))
+        return t;
+    if (t.startsWith('@'))
+        return t;
+    if (/^[A-Za-z_]\w*$/.test(t))
+        return `@${t}`;
+    return t;
+}
+/**
+ * Convert the inner text of a single AMPscript inline expression (`%%=…=%%`)
+ * to Handlebars, classifying function calls by the three conversion categories.
+ * @param inner - The expression between `%%=` and `=%%` (already trimmed).
+ * @param lineNum - Source line number for change/flag tracking.
+ * @param changes - Mutable change log.
+ * @param flaggedSections - Mutable flagged-section log.
+ * @returns {string} The Handlebars replacement string.
+ */
+function convertInlineAmpToHbs(inner, lineNum, changes, flaggedSections) {
+    // v(@x) / v(x) → {{x}}
+    const vMatch = /^v\s*\(\s*@?([A-Za-z_]\w*)\s*\)$/i.exec(inner);
+    if (vMatch) {
+        changes.push({ line: lineNum, description: `%%=v(@${vMatch[1]})=%% → {{${vMatch[1]}}}` });
+        return `{{${vMatch[1]}}}`;
+    }
+    // Bare @var / var → {{var}}
+    const varMatch = /^@?([A-Za-z_]\w*)$/.exec(inner);
+    if (varMatch) {
+        changes.push({ line: lineNum, description: `%%=${inner}=%% → {{${varMatch[1]}}}` });
+        return `{{${varMatch[1]}}}`;
+    }
+    // FunctionName(args)
+    const fnMatch = /^([A-Za-z_]\w*)\s*\(([\s\S]*)\)$/.exec(inner);
+    if (fnMatch) {
+        const fnName = fnMatch[1];
+        const key = fnName.toLowerCase();
+        const hbsArgs = splitArgs(fnMatch[2]).map((a) => ampArgToHbs(a));
+        // Category A — mapped helper.
+        const helper = AMP_TO_HANDLEBARS[key];
+        if (helper) {
+            changes.push({
+                line: lineNum,
+                description: `%%=${fnName}(…)=%% → {{${helper} …}}`,
+            });
+            return `{{${helper}${hbsArgs.length > 0 ? ' ' + hbsArgs.join(' ') : ''}}}`;
+        }
+        // Category C — mcnHandlebarsGap (distinct note from Category B).
+        if (AMP_MCN_HANDLEBARS_GAP.has(key)) {
+            flaggedSections.push({
+                line: lineNum,
+                code: `%%=${inner}=%%`,
+                reason: `${fnName} is ${HBS_GAP_NOTE}`,
+            });
+            return `{{!-- MANUAL_REWRITE_REQUIRED: ${fnName} is ${HBS_GAP_NOTE} --}}`;
+        }
+        // Category B — no Handlebars counterpart.
+        flaggedSections.push({
+            line: lineNum,
+            code: `%%=${inner}=%%`,
+            reason: `AMPscript function '${fnName}' has no Handlebars equivalent`,
+        });
+        return `{{!-- MANUAL_REWRITE_REQUIRED: AMPscript function '${fnName}' has no Handlebars equivalent --}}`;
+    }
+    // Anything else (complex expression).
+    flaggedSections.push({
+        line: lineNum,
+        code: `%%=${inner}=%%`,
+        reason: 'complex AMPscript expression has no direct Handlebars form',
+    });
+    return `{{!-- MANUAL_REWRITE_REQUIRED: ${inner} --}}`;
+}
+/**
+ * Convert AMPscript to MCN Handlebars using deterministic, data-driven rules.
+ *
+ * Inline expressions (`%%=Fn(args)=%%`, `%%=v(@x)=%%`, `%%var%%`) are mapped via
+ * the three conversion categories built from ampscript-data's
+ * `handlebarsEquivalent` / `mcnHandlebarsGap` fields:
+ * - **A** — mapped helper → `{{helper …}}`
+ * - **B** — no counterpart → `{{!-- MANUAL_REWRITE_REQUIRED … --}}`
+ * - **C** — `mcnHandlebarsGap` → `{{!-- MANUAL_REWRITE_REQUIRED … (distinct note) --}}`
+ *
+ * Procedural AMPscript blocks (`%%[ … ]%%`, `SET`/`VAR`/`IF`/`FOR`) have no
+ * Handlebars counterpart (Handlebars cannot assign variables or run imperative
+ * control flow) and are flagged MANUAL_REWRITE_REQUIRED.
+ * @param code - AMPscript source code (may include HTML context).
+ * @returns {ConversionResult} Converted Handlebars, change log, and flagged sections.
+ */
+export function ampscriptToHandlebars(code) {
+    const changes = [];
+    const flaggedSections = [];
+    const lines = code.split('\n');
+    const outputLines = [];
+    let inBlock = false;
+    for (const [i, line] of lines.entries()) {
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        // Track multi-line %%[ … ]%% blocks — flag the whole block once.
+        if (inBlock) {
+            if (/\]%%/.test(line))
+                inBlock = false;
+            continue;
+        }
+        if (/%%\[/.test(line)) {
+            if (!/\]%%/.test(line))
+                inBlock = true;
+            outputLines.push('{{!-- MANUAL_REWRITE_REQUIRED: AMPscript block (SET/VAR/IF/FOR) has no Handlebars equivalent — Handlebars cannot assign variables or run imperative control flow --}}');
+            flaggedSections.push({
+                line: lineNum,
+                code: trimmed.slice(0, 80),
+                reason: 'AMPscript procedural block has no Handlebars counterpart',
+            });
+            continue;
+        }
+        // Convert inline expressions on this line.
+        const converted = line
+            .replaceAll(/%%=\s*([\s\S]*?)\s*=%%/g, (_full, raw) => convertInlineAmpToHbs(raw.trim(), lineNum, changes, flaggedSections))
+            .replaceAll(/%%([A-Za-z_]\w*)%%/g, (_full, v) => {
+            changes.push({ line: lineNum, description: `%%${v}%% → {{${v}}}` });
+            return `{{${v}}}`;
+        });
+        outputLines.push(converted);
+    }
+    return { convertedCode: outputLines.join('\n'), changes, flaggedSections };
+}
+/**
+ * Convert MCN Handlebars to AMPscript using deterministic, data-driven rules.
+ *
+ * Inline helper calls (`{{helper args}}`) whose helper maps back to an AMPscript
+ * function (via HANDLEBARS_TO_AMP) become `%%=Fn(args)=%%`; bare variables
+ * (`{{name}}`) become `%%=v(@name)=%%`. Block helpers (`{{#each}}`…), partials
+ * (`{{> …}}`), dotted binding paths, and unknown helpers are flagged
+ * MANUAL_REWRITE_REQUIRED.
+ * @param code - Handlebars source code (may include HTML context).
+ * @returns {ConversionResult} Converted AMPscript, change log, and flagged sections.
+ */
+export function handlebarsToAmpscript(code) {
+    const changes = [];
+    const flaggedSections = [];
+    let lineCursor = 1;
+    let lastIndex = 0;
+    const convertedCode = code.replaceAll(/\{\{([\s\S]*?)\}\}/g, (full, raw, offset) => {
+        lineCursor += countNewlines(code.slice(lastIndex, offset));
+        lastIndex = offset;
+        const lineNum = lineCursor;
+        const inner = raw.trim();
+        // Comments — preserve as an AMPscript comment.
+        if (inner.startsWith('!')) {
+            return full;
+        }
+        // Block helpers / partials / closing tags — no deterministic AMPscript form.
+        if (/^[#/>]/.test(inner)) {
+            flaggedSections.push({
+                line: lineNum,
+                code: full,
+                reason: 'Handlebars block helper / partial has no direct AMPscript equivalent',
+            });
+            return `%%-- MANUAL_REWRITE_REQUIRED: ${full} --%%`;
+        }
+        // Strip a leading no-escape ampersand: {{& x}}.
+        const body = inner.replace(/^&\s*/, '');
+        // Helper with arguments: {{helper arg1 arg2 …}}
+        const fnMatch = /^([A-Za-z_]\w*)\s+(.+)$/.exec(body);
+        if (fnMatch) {
+            const helperName = fnMatch[1];
+            const key = helperName.toLowerCase();
+            const ampName = HANDLEBARS_TO_AMP[key];
+            const ampArgs = splitArgs(fnMatch[2]).map((a) => hbsArgToAmp(a));
+            if (ampName) {
+                changes.push({
+                    line: lineNum,
+                    description: `{{${helperName} …}} → %%=${ampName}(…)=%%`,
+                });
+                return `%%=${ampName}(${ampArgs.join(', ')})=%%`;
+            }
+            flaggedSections.push({
+                line: lineNum,
+                code: full,
+                reason: `Handlebars helper '${helperName}' has no AMPscript equivalent`,
+            });
+            return `%%-- MANUAL_REWRITE_REQUIRED: Handlebars helper '${helperName}' has no AMPscript equivalent --%%`;
+        }
+        // Bare single identifier: {{name}} → %%=v(@name)=%%
+        const bareMatch = /^([A-Za-z_]\w*)$/.exec(body);
+        if (bareMatch) {
+            changes.push({
+                line: lineNum,
+                description: `{{${bareMatch[1]}}} → %%=v(@${bareMatch[1]})=%%`,
+            });
+            return `%%=v(@${bareMatch[1]})=%%`;
+        }
+        // Dotted binding path or other expression — context-specific.
+        flaggedSections.push({
+            line: lineNum,
+            code: full,
+            reason: 'Handlebars binding path requires context-specific AMPscript mapping',
+        });
+        return `%%-- MANUAL_REWRITE_REQUIRED: ${full} --%%`;
+    });
+    return { convertedCode, changes, flaggedSections };
+}
+/**
+ * Count newline characters in a string (helper for line tracking in
+ * handlebarsToAmpscript).
+ * @param s - Input string.
+ * @returns {number} Number of `\n` characters.
+ */
+function countNewlines(s) {
+    let n = 0;
+    for (const ch of s) {
+        if (ch === '\n')
+            n++;
+    }
+    return n;
+}
+/**
+ * Convert SSJS to MCN Handlebars deterministically via a two-step chain:
+ * SSJS → AMPscript (`ssjsToAmpscript`) → Handlebars (`ampscriptToHandlebars`).
+ *
+ * Because Handlebars is declarative, most imperative SSJS has no Handlebars
+ * counterpart and is conservatively flagged MANUAL_REWRITE_REQUIRED; inline
+ * `Platform.Function.X(…)` calls that map through AMPscript to a Handlebars
+ * helper are converted.
+ * @param code - SSJS source code (may include `<script runat="server">` tags).
+ * @returns {ConversionResult} Converted Handlebars, combined change log, and flagged sections.
+ */
+export function ssjsToHandlebars(code) {
+    const toAmp = ssjsToAmpscript(code);
+    const toHbs = ampscriptToHandlebars(toAmp.convertedCode);
+    return {
+        convertedCode: toHbs.convertedCode,
+        changes: [
+            ...toAmp.changes.map((c) => ({
+                line: c.line,
+                description: `[SSJS→AMPscript] ${c.description}`,
+            })),
+            ...toHbs.changes.map((c) => ({
+                line: c.line,
+                description: `[AMPscript→Handlebars] ${c.description}`,
+            })),
+        ],
+        flaggedSections: [...toAmp.flaggedSections, ...toHbs.flaggedSections],
+    };
+}
 /**
  * Rewrite AMPscript code to be compatible with Marketing Cloud Next.
  *