@cspeach/cli 1.1.1 → 1.1.3

package/dist/sap/standalone-profile.js

@@ -0,0 +1,237 @@
+/**
+ * Standalone-mode SAP profile — the "what system would this land on?" facts a
+ * prospect gives us ONCE when they run CSPeach without a SAP connection
+ * (`--no-sap` / `no_sap = true`).
+ *
+ * This module is PURE: types, whitelists, derivations and rendering only. The
+ * interactive wizard lives in `standalone-onboarding.ts` so tests never pull in
+ * `@inquirer/prompts`, and `config/loader.ts` can import the shape + sanitiser
+ * without a prompt dependency.
+ *
+ * The rendered element deliberately reuses the CONNECTED `<sap_system …/>`
+ * shape (see sap/system-info.ts `renderSapSystemBlock`) so skills read one
+ * element in both modes and need no change.
+ */
+export const STANDALONE_PLATFORMS = [
+    'ECC',
+    'S/4HANA',
+    'S/4HANA Cloud Private',
+    'S/4HANA Cloud Public',
+    'BTP ABAP Environment',
+];
+export const STANDALONE_DATABASES = ['HANA', 'other'];
+export const STANDALONE_DEPLOYMENTS = ['on-prem', 'private-cloud', 'public-cloud'];
+export const STANDALONE_IDES = ['ADT', 'SE80', 'both'];
+/** The three platforms that are "cloud" for defaulting purposes. */
+const CLOUD_PLATFORMS = new Set([
+    'S/4HANA Cloud Private',
+    'S/4HANA Cloud Public',
+    'BTP ABAP Environment',
+]);
+export function isStandalonePlatform(v) {
+    return typeof v === 'string' && STANDALONE_PLATFORMS.includes(v);
+}
+/**
+ * Deployment implied by the platform. `null` means "the platform doesn't decide
+ * it — ask the user" (ECC and on-prem S/4HANA can both be on-prem or hosted in
+ * a private cloud).
+ */
+export function deriveDeployment(platform) {
+    switch (platform) {
+        case 'S/4HANA Cloud Public':
+        case 'BTP ABAP Environment':
+            return 'public-cloud';
+        case 'S/4HANA Cloud Private':
+            return 'private-cloud';
+        default:
+            return null;
+    }
+}
+/**
+ * Database implied by the platform. S/4HANA (any edition) and BTP ABAP are
+ * HANA by definition; only ECC can sit on something else. `null` = ask.
+ */
+export function deriveDatabase(platform) {
+    return platform === 'ECC' ? null : 'HANA';
+}
+/** Default answer to "must new code be ABAP Cloud / clean-core compliant?". */
+export function defaultAbapCloudOnly(platform) {
+    return CLOUD_PLATFORMS.has(platform);
+}
+/** Release examples shown in the wizard prompt, per platform. */
+export function releaseExamples(platform) {
+    switch (platform) {
+        case 'ECC':
+            return '6.0 EhP8 / NW 7.50';
+        case 'S/4HANA':
+            return '2023 FPS01 / 2022 / 2021 / 1909';
+        case 'S/4HANA Cloud Private':
+            return '2023 FPS01 / 2022 / current';
+        default:
+            return 'current';
+    }
+}
+/** Pre-filled answer for the release prompt, per platform. */
+export function defaultRelease(platform) {
+    switch (platform) {
+        case 'ECC':
+            return '6.0 EhP8';
+        case 'S/4HANA':
+        case 'S/4HANA Cloud Private':
+            return '2023';
+        default:
+            return 'current';
+    }
+}
+/** S/4HANA release year → SAP_BASIS / ABAP language version. */
+const S4_YEAR_TO_ABAP = {
+    '1909': '7.54',
+    '2020': '7.55',
+    '2021': '7.56',
+    '2022': '7.57',
+    '2023': '7.58',
+    '2025': '7.59',
+};
+function releaseYear(release) {
+    for (const year of Object.keys(S4_YEAR_TO_ABAP)) {
+        // Word-boundary match so "2023 FPS01" and "S/4HANA 2022 FPS02" both land.
+        if (new RegExp(`(^|\\D)${year}(\\D|$)`).test(release))
+            return year;
+    }
+    return undefined;
+}
+/**
+ * Map platform + release to the `abap_version` attribute skills already read
+ * from the connected `<sap_system>` element.
+ *
+ * Note on S/4HANA Cloud Private: it runs the SAME on-prem code line, so when
+ * the user states a release year we report the real ABAP version (2023 → 7.58)
+ * instead of the generic "ABAP Cloud" marker. Only a year-less answer
+ * ("current") falls back to "ABAP Cloud".
+ */
+export function mapAbapVersion(platform, release) {
+    switch (platform) {
+        case 'ECC':
+            return '7.50 (classic ABAP, no ABAP Cloud)';
+        case 'S/4HANA': {
+            const y = releaseYear(release);
+            return y ? S4_YEAR_TO_ABAP[y] : 'unknown';
+        }
+        case 'S/4HANA Cloud Private': {
+            const y = releaseYear(release);
+            return y ? S4_YEAR_TO_ABAP[y] : 'ABAP Cloud';
+        }
+        default:
+            return 'ABAP Cloud';
+    }
+}
+/** Map the profile's deployment onto the existing `SapDeployment` values. */
+export function mapSapDeployment(deployment) {
+    return deployment === 'public-cloud' ? 'public-cloud' : 'on-prem-or-private-cloud';
+}
+/**
+ * Coerce a possibly-hand-edited `[standalone]` TOML table into a valid profile.
+ *
+ * The platform is load-bearing (every other default derives from it), so an
+ * unrecognised platform drops the WHOLE table — better a clean "profile not
+ * set" than a confident wrong release rendered into every prompt. Individual
+ * bad sub-fields are repaired from the platform defaults.
+ */
+export function sanitiseStandaloneProfile(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return undefined;
+    const r = raw;
+    if (!isStandalonePlatform(r.platform))
+        return undefined;
+    const platform = r.platform;
+    const release = typeof r.release === 'string' && r.release.trim().length > 0
+        ? r.release.trim()
+        : defaultRelease(platform);
+    const database = typeof r.database === 'string' && STANDALONE_DATABASES.includes(r.database)
+        ? r.database
+        : (deriveDatabase(platform) ?? 'HANA');
+    const deployment = typeof r.deployment === 'string' && STANDALONE_DEPLOYMENTS.includes(r.deployment)
+        ? r.deployment
+        : (deriveDeployment(platform) ?? 'on-prem');
+    const ide = typeof r.ide === 'string' && STANDALONE_IDES.includes(r.ide)
+        ? r.ide
+        : 'ADT';
+    const profile = {
+        platform,
+        release,
+        database,
+        deployment,
+        ide,
+        abap_cloud_only: typeof r.abap_cloud_only === 'boolean' ? r.abap_cloud_only : defaultAbapCloudOnly(platform),
+    };
+    if (typeof r.notes === 'string' && r.notes.trim().length > 0)
+        profile.notes = r.notes.trim();
+    return profile;
+}
+function escapeAttr(s) {
+    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/** Hard cap on the free-text `notes` attribute, so one long line can't bloat every turn. */
+export const STANDALONE_NOTES_MAX_CHARS = 200;
+/**
+ * Render the standalone `<sap_system …/>` element — the SAME element name the
+ * connected path emits, with `connected="false" mode="standalone"` plus the
+ * three extra facts the profile knows (database / ide / abap_cloud_only).
+ *
+ * With no profile every fact renders as "unknown" rather than being omitted:
+ * a uniform attribute set is easier for a skill to read than a shape that
+ * changes depending on what the user answered.
+ */
+export function renderStandaloneSapSystemBlock(profile) {
+    const platform = profile ? profile.platform : 'unknown';
+    const release = profile ? profile.release : 'unknown';
+    const abapVersion = profile ? mapAbapVersion(profile.platform, profile.release) : 'unknown';
+    const deployment = profile ? mapSapDeployment(profile.deployment) : 'unknown';
+    const database = profile ? profile.database : 'unknown';
+    const ide = profile ? profile.ide : 'unknown';
+    const cloudOnly = profile ? String(profile.abap_cloud_only ?? defaultAbapCloudOnly(profile.platform)) : 'unknown';
+    const attrs = [
+        `platform="${escapeAttr(platform)}"`,
+        `release="${escapeAttr(release)}"`,
+        `abap_version="${escapeAttr(abapVersion)}"`,
+        `deployment="${escapeAttr(deployment)}"`,
+        `connected="false"`,
+        `mode="standalone"`,
+        `database="${escapeAttr(database)}"`,
+        `ide="${escapeAttr(ide)}"`,
+        `abap_cloud_only="${escapeAttr(cloudOnly)}"`,
+    ];
+    // `notes` is the user's own free-text constraint ("no BTP", "transports via
+    // ChaRM") — worth giving the model, but only when they actually answered:
+    // the attribute is OMITTED entirely rather than rendered empty/"unknown".
+    const notes = profile?.notes?.trim();
+    if (notes) {
+        attrs.push(`notes="${escapeAttr(notes.slice(0, STANDALONE_NOTES_MAX_CHARS))}"`);
+    }
+    return `<sap_system ${attrs.join(' ')}/>`;
+}
+/**
+ * The manual-implementation hand-off rule. Standalone cannot create or activate
+ * anything, so every would-be write has to end as instructions the developer
+ * can follow by hand — on disk when the file tools are available, otherwise in
+ * the reply — plus the rule for repairing a single failed step.
+ */
+export const STANDALONE_NOTE = '<standalone_note>No SAP system is connected (standalone mode). Do not call SAP tools. ' +
+    'Work from code the user pastes or describes; when a task needs system data (source, table definitions, ATC output, dumps), ask the user to paste it. ' +
+    'Target the platform and release in sap_system exactly — use only syntax and APIs available on that release. ' +
+    'Because nothing can be created or activated here, every task that would normally write to SAP must instead end with a "Manual Implementation Guide": ' +
+    'numbered steps in dependency order, one object per step, each stating the object type and name, where to create it (ADT wizard path, or SE80/SE11/SE24/SE38 transaction for SE80 teams), ' +
+    'the exact source to paste, the activation step, and any prerequisite (package, transport, number range, message class). ' +
+    'Finish with a short verification checklist (syntax check, activation, ATC, unit test) the user can run themselves.\n' +
+    'File outputs: when file tools are available (local build is on), also write every produced object to the working folder as ./cspeach-out/<yyyy-mm-dd>-<short-task-name>/NN-<OBJECT_NAME>.<abap|ddls|bdef|srvd|srvb|ddlx|dcls|txt> in dependency order, and write the Manual Implementation Guide to GUIDE.md in the same folder, with each step pointing at its file. Tell the user the folder path once. If file tools are not available, say so once and keep everything in the reply.\n' +
+    'Step failures: when the user reports a failure at a step ("step 3 failed" plus an error message or screenshot), ask only for what is missing to diagnose it, fix only the affected object, rewrite its file, re-issue that step and any step that depends on it, and state which steps are unchanged. Never restart the whole guide.</standalone_note>';
+/**
+ * The full standalone contribution to `<session_context>`: the sap_system
+ * element followed by the hand-off note.
+ *
+ * `formatFactBlock` (router/intent-extractor.ts) indents only the FIRST line of
+ * the block it is handed, so every following line carries its own two spaces.
+ */
+export function renderStandaloneContextBlock(profile) {
+    return `${renderStandaloneSapSystemBlock(profile)}\n  ${STANDALONE_NOTE}`;
+}