@cspeach/cli 1.1.34 → 1.1.36

package/dist/tools/rap/skeleton-resolve.js

@@ -0,0 +1,283 @@
+// cspeach-cli/src/tools/rap/skeleton-resolve.ts
+//
+// RAP generator plan, Task 7 — `rap_skeleton_resolve`. Spec 2026-10-14 §3.2/§4:
+// the CLI picks the skeleton builder (SAP's generator or the CSPeach writer),
+// shows the skeleton card, writes the sha-pinned decision file and returns the
+// block the plan copies. The model never picks.
+//
+// Every SAP read here is best-effort: a read that throws (other than the
+// table's own 404) makes the generator fact 'unknown', so the CSPeach writer
+// is chosen (row 3). The tool never crashes on a SAP read.
+import { SapError } from '@cspeach/sap-client';
+import { isStandalone, registerTool } from '../index.js';
+import { assertNotCliHome, laneRootFor } from '../../lane/roots.js';
+import { setLatestSkeletonDecision } from '../../rap/skeleton-session.js';
+import { factsFromSystemInfo } from '../../lane/inputs.js';
+import { cardLine } from '../../lane/card.js';
+import { getSapSystemInfo } from '../../sap/system-info.js';
+import { getGeneratorFact } from '../../sap/generator-fact.js';
+import { decideSkeleton, generatorBlockers, } from '../../rap/skeleton-rules.js';
+import { buildUiserviceContent, generatorPlannedObjects, namesFitLimits, proposeNames, } from '../../rap/generator-names.js';
+import { writeSkeletonDecision } from '../../rap/skeleton-store.js';
+import { SKELETON_WHO, skeletonCardRequest } from '../../rap/skeleton-card.js';
+import { PKG_RE } from '../../projects/plan-objects.js';
+import { askConfirm } from '../../ui/confirm-request.js';
+import { cardSlotEmitter } from '../../ui/card-slot.js';
+import { isHeadless } from '../../renderer/tty.js';
+const fail = (m) => ({ content: `error: ${m}`, is_error: true });
+const NOT_CHOSEN = 'Skeleton not chosen. Nothing was saved.';
+const TABLE_RE = /^[ZY][A-Z0-9_]{1,15}$/;
+const BINDINGS = new Set(['odata-v4-ui', 'odata-v2-ui', 'odata-v4-api', 'odata-v2-api']);
+const RAP_TIER = (t) => t === 's4-2020-plus' || t === 'unknown';
+const TS_FIELDS = [/:\s*abp_locinst_lastchange_tstmpl\b/i, /:\s*abp_lastchange_tstmpl\b/i];
+function parseRequest(r) {
+    if (!r || typeof r !== 'object')
+        return null;
+    const o = r;
+    if (typeof o.entities !== 'number' || !Number.isInteger(o.entities) || o.entities < 1)
+        return null;
+    if (o.implementation !== 'managed' && o.implementation !== 'unmanaged')
+        return null;
+    if (typeof o.draft !== 'boolean' || typeof o.binding !== 'string' || !BINDINGS.has(o.binding))
+        return null;
+    return {
+        entities: o.entities, implementation: o.implementation, draft: o.draft,
+        binding: o.binding,
+    };
+}
+async function defaultTier(ctx) {
+    return { tier: factsFromSystemInfo(await getSapSystemInfo(ctx.adt, ctx.sapAlias)).tier };
+}
+function defaultHeadless() {
+    return isHeadless() || cardSlotEmitter.listenerCount('confirm') === 0;
+}
+const SUFFIXES = ['', '2', '3', '4', '5', '6', '7', '8', '9'];
+const RENAMED_NOTE = 'Some names were taken, so CSPeach picked free ones';
+const takenMessage = (name) => `${name} already exists in the system. Choose another table or app name, then run /abap-plan again.`;
+/** The name a SAP validation text says is taken, when it is one of ours. */
+function clashInValidation(text, objects) {
+    if (!/already exist/i.test(text))
+        return null;
+    const up = text.toUpperCase();
+    const hit = objects.find((o) => {
+        const at = up.indexOf(o.name);
+        if (at < 0)
+            return false;
+        const before = at === 0 ? '' : up[at - 1];
+        const after = up[at + o.name.length] ?? '';
+        return !/[A-Z0-9_]/.test(before) && !/[A-Z0-9_]/.test(after);
+    });
+    return hit ? hit.name : null;
+}
+/** First of `objects` that already exists (exact name), or null. Throws what searchObject throws. */
+async function searchClash(ctx, objects) {
+    for (const o of objects) {
+        const hits = await ctx.adt.searchObject(o.name, o.type, 5);
+        if (hits.some((h) => String(h.name).toUpperCase() === o.name))
+            return o.name;
+    }
+    return null;
+}
+/**
+ * Fills the table facts (rows 5–7) from SAP for one candidate name set and
+ * returns the name of one of OUR objects that is already taken, or null.
+ * Throws only what the caller maps to generator 'unknown'; a 404 on the table
+ * means "not created yet".
+ */
+async function probeTable(ctx, facts, names, objects9, content, cache) {
+    if (cache.src === undefined) {
+        try {
+            cache.src = await ctx.adt.getSource('TABL', names.table);
+        }
+        catch (e) {
+            if (!(e instanceof SapError && e.httpStatus === 404))
+                throw e;
+            cache.src = null;
+        }
+    }
+    if (cache.src !== null) {
+        const text = cache.src;
+        facts.tableExists = true;
+        facts.tableHasTimestamps = TS_FIELDS.every((re) => re.test(text));
+        if (!facts.tableHasTimestamps)
+            return null;
+        if (cache.ui === undefined) {
+            const list = await ctx.adt.listGenerators(`/sap/bc/adt/ddic/tables/${names.table.toLowerCase()}`);
+            cache.ui = list.find((g) => g.id === 'uiservice') ?? null;
+        }
+        facts.uiserviceOffered = !!cache.ui;
+        if (cache.ui) {
+            const v = await ctx.adt.validateGenerator(cache.ui, content);
+            // Final review I3 — a clash on one of our names is renamed, not a row-7 stop.
+            const clash = v.ok ? null : clashInValidation(v.text, objects9);
+            if (clash)
+                return clash;
+            facts.validation = { ok: v.ok, text: v.text };
+        }
+        return null;
+    }
+    // Not created yet: SAP's own validation needs the table, so check the 9 names here.
+    return searchClash(ctx, objects9);
+}
+/** The objects the CSPeach writer builds under the record's names (no draft table without draft). */
+function writerObjects(objects9, request) {
+    return request.draft ? objects9 : objects9.filter((o) => o.type !== 'TABL');
+}
+export async function rapSkeletonResolveHandler(args, ctx, deps = {}) {
+    // 1. Arguments.
+    const table = String(args?.table ?? '').trim().toUpperCase();
+    if (!TABLE_RE.test(table))
+        return fail('table must be a Z/Y table name of at most 16 characters.');
+    const pkg = String(args?.package ?? '').trim().toUpperCase();
+    if (!PKG_RE.test(pkg))
+        return fail('package must be a valid package name.');
+    const request = parseRequest(args?.request);
+    if (!request) {
+        return fail('request must be { entities, implementation: managed|unmanaged, draft, binding: odata-v4-ui|odata-v2-ui|odata-v4-api|odata-v2-api }.');
+    }
+    const description = (String(args?.description ?? '').trim() || table).slice(0, 60);
+    // 2. System facts. Final review I1 — standalone (or no SAP client): no SAP read at all.
+    const connected = !isStandalone(ctx) && !!ctx.adt;
+    const { tier } = connected
+        ? await (deps.facts ?? defaultTier)(ctx).catch(() => ({ tier: 'unknown' }))
+        : { tier: 'unknown' };
+    let generator = connected
+        ? await (deps.generatorFact ?? ((c) => getGeneratorFact(c.adt, c.sapAlias)))(ctx)
+            .catch(() => 'unknown')
+        : 'unknown';
+    // 3–4. Names, then the table facts. Final review I3 — a taken name is never
+    // handed on: each candidate set (base, base2 … base9) is checked the same way
+    // and the first free set wins. When SAP can't be searched the names stay unchecked.
+    const cache = {};
+    let chosen = null;
+    let firstTaken = null;
+    for (const suffix of SUFFIXES) {
+        const names = proposeNames(table, suffix);
+        const facts = {
+            tier, generator, tableExists: false, tableHasTimestamps: null, uiserviceOffered: null, validation: null,
+            namesFit: namesFitLimits(names), connected, localPackage: pkg.startsWith('$'),
+        };
+        const objects9 = generatorPlannedObjects(names, pkg);
+        const content = buildUiserviceContent(names, pkg, description);
+        let taken = null;
+        // Only when the generator could still be chosen.
+        if (RAP_TIER(tier) && generator === 'yes' && !generatorBlockers(request, facts)) {
+            try {
+                taken = await probeTable(ctx, facts, names, objects9, content, cache);
+            }
+            catch {
+                generator = 'unknown';
+                facts.generator = 'unknown';
+            }
+        }
+        // The CSPeach writer builds the same names: check them when it is the one deciding.
+        if (!taken && connected && RAP_TIER(tier) && generatorBlockers(request, facts)) {
+            try {
+                taken = await searchClash(ctx, writerObjects(objects9, request));
+            }
+            catch {
+                taken = null; // SAP can't be searched: the names stay unchecked (the build reports a clash).
+            }
+        }
+        if (!taken) {
+            chosen = { names, facts, objects9, content };
+            break;
+        }
+        firstTaken ??= taken;
+    }
+    if (!chosen)
+        return { content: takenMessage(firstTaken ?? table) };
+    const { names, facts, objects9, content } = chosen;
+    const renamed = names.base !== proposeNames(table).base;
+    const noted = (d) => (renamed && d.by !== null ? { ...d, reason: `${d.reason}. ${RENAMED_NOTE}` } : d);
+    // 5. Decide.
+    let decision = noted(decideSkeleton(request, facts));
+    if (decision.by === null)
+        return { content: `${decision.reason}. Nothing was saved.` };
+    const blocked = generatorBlockers(request, facts);
+    // 6. Card, or the rules when no card can be shown.
+    if ((deps.headless ?? defaultHeadless)()) {
+        ctx.chunkEmitter?.emit('info', `RAP skeleton chosen by the rules (no confirm card here): ${SKELETON_WHO[decision.by]}.`);
+    }
+    else {
+        const card = skeletonCardRequest(decision, blocked?.reason ?? null, names, objects9);
+        const res = await (deps.confirm ?? ((r) => askConfirm(r)))(card);
+        const value = res.value;
+        const offered = new Set(card.choices.map((c) => c.value));
+        if (!value || value === 'cancel' || !offered.has(value))
+            return { content: NOT_CHOSEN };
+        if (value.startsWith('switch:')) {
+            decision = noted(decideSkeleton(request, facts, value.slice('switch:'.length)));
+        }
+        else if (value !== 'confirm') {
+            return { content: NOT_CHOSEN };
+        }
+    }
+    const by = decision.by;
+    if (by === null)
+        return { content: NOT_CHOSEN };
+    // 7. The decision file.
+    const objects = by === 'sap-generator' ? objects9 : [];
+    let written;
+    try {
+        const laneRoot = await laneRootFor(ctx.cwd);
+        await assertNotCliHome(laneRoot);
+        written = await writeSkeletonDecision(laneRoot, {
+            table, package: pkg, names, request, decision, objects,
+            ...(by === 'sap-generator' ? { content } : {}),
+        });
+    }
+    catch (e) {
+        return fail(`the skeleton decision could not be saved: ${cardLine(e instanceof Error ? e.message : 'write failed')}`);
+    }
+    // Task 8 fix round 1 — the plan save accepts only this, the newest decision.
+    if (ctx.session)
+        setLatestSkeletonDecision(ctx.session, written);
+    // 8. The result.
+    const block = { skeleton: { by, decision: { path: written.path, sha256: written.sha256 } }, plannedObjects: objects };
+    return {
+        content: [
+            `Skeleton: ${SKELETON_WHO[by]} — ${cardLine(decision.reason)}`,
+            `Decision file: ${written.path}`,
+            `Plan block: ${JSON.stringify(block)}`,
+            // Final review I3 — the writer builds the record's names (checked free, renamed when taken).
+            ...(by === 'cspeach'
+                ? [`Names: ${[names.root, names.projection, names.behaviorPool, ...(request.draft ? [names.draftTable] : []), names.serviceBinding].join(', ')} `
+                        + '(service definition and binding). Use exactly these names for the skeleton objects.']
+                : []),
+            "Copy the plan block into the skeleton phase's work exactly as given. Do not change it.",
+        ].join('\n'),
+    };
+}
+registerTool({
+    name: 'rap_skeleton_resolve',
+    description: "RAP apps only, at plan time. Decides how the RAP skeleton is built: SAP's generator or the CSPeach writer. "
+        + 'Pass the persistence table name (it may not exist yet), the package, a short description and the request '
+        + '{ entities (number of entities incl. children), implementation managed|unmanaged, draft, binding '
+        + 'odata-v4-ui|odata-v2-ui|odata-v4-api|odata-v2-api }. CSPeach checks the system and the table, shows the '
+        + "skeleton card, saves the decision and returns a Plan block. Copy that block into the skeleton phase's "
+        + 'work exactly. Never choose the builder yourself.',
+    isMutating: false,
+    // Final review I1 — usable standalone: no SAP reads, the CSPeach writer ("Not connected to SAP").
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            table: { type: 'string', description: 'Persistence table name (Z/Y, at most 16 characters)' },
+            package: { type: 'string', description: 'Target package' },
+            description: { type: 'string', description: 'Short business description, e.g. "Equipment downtime log"' },
+            request: {
+                type: 'object',
+                properties: {
+                    entities: { type: 'integer', minimum: 1 },
+                    implementation: { type: 'string', enum: ['managed', 'unmanaged'] },
+                    draft: { type: 'boolean' },
+                    binding: { type: 'string', enum: ['odata-v4-ui', 'odata-v2-ui', 'odata-v4-api', 'odata-v2-api'] },
+                },
+                required: ['entities', 'implementation', 'draft', 'binding'],
+            },
+        },
+        required: ['table', 'package', 'description', 'request'],
+    },
+    handler: (args, ctx) => rapSkeletonResolveHandler(args, ctx),
+});

package/dist/tools/sap-read.js

@@ -644,29 +644,29 @@ registerTool({
     handler: async (args, ctx) => {
         // runUnitTest(type, name) — type first
         const result = await ctx.adt.runUnitTest(args.type, args.name);
-        // B2 false-green guard (project_aunit_run_gap): the ADT AUnit-run endpoint
-        // returns HTTP 200 with an EMPTY runResult (total:0, no programs) even for a
-        // class that is active + syntax-clean with a valid FOR TESTING local class —
-        // a known environmental gap, exhaustively probed (sap-client buildUnitTestXml
-        // comment). The raw {total:0} shape reads to a caller like "0 tests, nothing
-        // failed → green", so an unguarded pass-through risks a false-green test gate.
-        // When we detect that empty signature, wrap the (still-carried) raw result in
-        // an explicit UNVERIFIED envelope that names Eclipse "Run As → ABAP Unit" as
-        // the authoritative check. A genuine run (total > 0) passes through unchanged.
-        const summary = result?.summary;
-        const programs = result?.programs;
-        const noTestsRun = summary?.total === 0 && (!Array.isArray(programs) || programs.length === 0);
-        if (noTestsRun) {
+        // B2 false-green guard: a run in which no test actually ran reads to a
+        // caller like "nothing failed → green". Wrap the (still-carried) raw result
+        // in an explicit UNVERIFIED envelope when:
+        //   - total is 0, missing or not a number — even when programs are present
+        //     (a class with no methods, or only tolerable class alerts; review I1);
+        //   - every test was skipped (total > 0, passed 0, failed 0; review M1).
+        // It is no longer blamed on an ADT gap: the 2026-10-12 sap-client fix sends
+        // the request shape Eclipse sends. A run with a pass or a failure passes
+        // through unchanged.
+        const summary = result
+            ?.summary;
+        const total = summary?.total;
+        const noTestsRun = typeof total !== 'number' || !Number.isFinite(total) || total === 0;
+        const allSkipped = !noTestsRun && summary?.passed === 0 && summary?.failed === 0;
+        if (noTestsRun || allSkipped) {
+            const n = total;
+            const warning = noTestsRun
+                ? '0 tests ran — this is not a pass. Check that the object has an active test ' +
+                    'class (FOR TESTING) with active test methods, then run it again.'
+                : `${n === 1 ? '1 test was' : `${n} tests were`} skipped and none ran — this is not ` +
+                    'a pass. Check the risk level and duration of the test classes, then run it again.';
             return {
-                content: JSON.stringify({
-                    verification: 'UNVERIFIED',
-                    warning: 'ABAP Unit run enumerated 0 tests (empty runResult). This does NOT mean the tests ' +
-                        'passed — it means none executed. A FOR TESTING class that is active + syntax-clean ' +
-                        'still returning 0 is a known ADT AUnit-run gap (project_aunit_run_gap): the ' +
-                        'authoritative check is Eclipse "Run As → ABAP Unit" (Ctrl+Shift+F10). Do NOT treat ' +
-                        'this as a green test gate.',
-                    result,
-                }, null, 2),
+                content: JSON.stringify({ verification: 'UNVERIFIED', warning, result }, null, 2),
             };
         }
         return { content: JSON.stringify(result, null, 2) };