@cspeach/cli 1.1.34 → 1.1.36

package/dist/tools/rap/finish-check.js

@@ -0,0 +1,118 @@
+// cspeach-cli/src/tools/rap/finish-check.ts
+//
+// RAP generator plan, Task 10 — `rap_finish_check` (spec 2026-10-14 §6).
+// Reads the app's live sources (root + projection DDLS, root BDEF, behavior
+// pool CCIMP, projection DDLX, table, access controls) and reports the Finish
+// items F1–F5 item by item, so the model cannot claim them done.
+//
+// A read that fails is never a pass:
+//   - a 404 on the DDLX is the F4 problem "No metadata extension for <projection>";
+//   - any other failed read (a 404 on the DDLS, BDEF, class include or table,
+//     or any non-404 error) is a tool error naming the object.
+import { registerTool } from '../index.js';
+import { checkFinish, FINISH_TITLES } from '../../rap/finish-checks.js';
+const fail = (m) => ({ content: `error: ${m}`, is_error: true });
+const NAME_RE = /^[A-Za-z0-9_/]{1,40}$/;
+class ReadFailed extends Error {
+}
+function httpStatus(e) {
+    const s = e?.httpStatus;
+    return typeof s === 'number' ? s : undefined;
+}
+/** Reads one object; a 404 returns undefined only when `allow404`, every other failure throws ReadFailed. */
+async function read(what, fn, allow404 = false) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        const status = httpStatus(e);
+        if (status === 404 && allow404)
+            return undefined;
+        if (status === 404)
+            throw new ReadFailed(`${what} not found. Build the app first, then run the finish check.`);
+        const why = status !== undefined ? `HTTP ${status}` : (e instanceof Error ? e.message : String(e));
+        throw new ReadFailed(`could not read ${what} (${why}). Nothing was checked.`);
+    }
+}
+export function formatFinish(items) {
+    const passed = items.filter((i) => i.ok).length;
+    return [
+        `Finish check: ${passed} of ${items.length} passed`,
+        ...items.map((i) => `${i.id} ${FINISH_TITLES[i.id]} — ${i.ok ? 'passed' : `needs work: ${i.problems.join('; ')}`}`),
+    ].join('\n');
+}
+export async function rapFinishCheckHandler(args, ctx) {
+    const names = {};
+    for (const k of ['root', 'projection', 'behaviorPool', 'entity']) {
+        const v = args[k];
+        if (typeof v !== 'string' || !NAME_RE.test(v.trim()))
+            return fail(`${k} is required (an object name)`);
+        names[k] = k === 'entity' ? v.trim() : v.trim().toUpperCase();
+    }
+    const { root, projection, behaviorPool, entity } = names;
+    let table;
+    if (args.table !== undefined && args.table !== null && args.table !== '') {
+        if (typeof args.table !== 'string' || !NAME_RE.test(args.table.trim()))
+            return fail('table must be a table name');
+        table = args.table.trim().toUpperCase();
+    }
+    let authObject;
+    if (args.authObject !== undefined && args.authObject !== null && args.authObject !== '') {
+        if (typeof args.authObject !== 'string' || !/^[A-Za-z0-9_]{1,10}$/.test(args.authObject.trim())) {
+            return fail('authObject must be an authorization object name');
+        }
+        authObject = args.authObject.trim().toUpperCase();
+    }
+    let codedFields = [];
+    if (args.codedFields !== undefined && args.codedFields !== null) {
+        if (!Array.isArray(args.codedFields) || !args.codedFields.every((f) => typeof f === 'string' && /^\w+$/.test(f.trim()))) {
+            return fail('codedFields must be a list of element names');
+        }
+        codedFields = args.codedFields.map((f) => f.trim());
+    }
+    const adt = ctx.adt;
+    let src;
+    try {
+        const rootDdls = (await read(`CDS view ${root}`, () => adt.getSource('DDLS', root)));
+        const projectionDdls = (await read(`CDS view ${projection}`, () => adt.getSource('DDLS', projection)));
+        const rootBdef = (await read(`behavior definition ${root}`, () => adt.getSource('BDEF', root)));
+        const ccimp = String((await read(`local types of ${behaviorPool}`, () => adt.classIncludes(behaviorPool, 'locals_imp'))));
+        const ddlx = await read(`metadata extension ${projection}`, () => adt.getSource('DDLX', projection), true);
+        const tableSrc = table ? await read(`table ${table}`, () => adt.getSource('TABL', table)) : undefined;
+        const dclsNames = [];
+        for (const n of [root, projection]) {
+            const hits = (await read(`access controls for ${n}`, () => adt.searchObject(n, 'DCLS', 10)));
+            if (hits.some((h) => h.name.toUpperCase() === n && /^DCLS(\/|$)/i.test(h.type)))
+                dclsNames.push(n);
+        }
+        src = { rootDdls, projectionDdls, rootBdef, ccimp, dclsNames, ...(ddlx !== undefined ? { ddlx } : {}), ...(tableSrc !== undefined ? { table: tableSrc } : {}) };
+    }
+    catch (e) {
+        if (e instanceof ReadFailed)
+            return fail(e.message);
+        throw e;
+    }
+    return { content: formatFinish(checkFinish(src, { root, projection, entity, authObject, codedFields })) };
+}
+registerTool({
+    name: 'rap_finish_check',
+    description: 'Check the Finish items F1–F5 of a RAP app against its live sources (authorization, access control, '
+        + 'read-only admin fields, labels, coded fields). Read-only. Run it after the Finish step and before the UI. '
+        + 'A failed item lists what to fix; fix only those and run it again.',
+    isMutating: false,
+    requiresSap: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            root: { type: 'string', description: 'Root interface view (ZR_…); also the root behavior definition' },
+            projection: { type: 'string', description: 'Projection view (ZC_…); its metadata extension has the same name' },
+            behaviorPool: { type: 'string', description: 'Behavior pool class (ZBP_…)' },
+            entity: { type: 'string', description: 'The BDEF entity alias, e.g. SbsBook2 (the app title must not be this)' },
+            table: { type: 'string', description: 'Persistence table, to check a UUID key uses managed numbering' },
+            authObject: { type: 'string', description: 'Authorization object from the spec; the auth method must check it' },
+            codedFields: { type: 'array', items: { type: 'string' }, description: 'Elements with a fixed code list (status, type, currency …)' },
+        },
+        required: ['root', 'projection', 'behaviorPool', 'entity'],
+    },
+    handler: (args, ctx) => rapFinishCheckHandler(args, ctx),
+});

package/dist/tools/rap/generate-objects.js

@@ -0,0 +1,317 @@
+// cspeach-cli/src/tools/rap/generate-objects.ts
+//
+// RAP generator plan, Task 9 — `sap_generate_objects` (spec 2026-10-14 §5).
+// Runs SAP's RAP generator (uiservice) for a skeleton phase whose decision
+// says sap-generator, under the usual write gates:
+//   decision file → approvals (one per planned object) → transport fit →
+//   table ready → generator offered → validate again → preview again →
+//   pending entry → generate → read back (active, on the plan's transport) →
+//   audit + finalize.
+// A failure stops and returns a plain-words error. A failed generate (an SAP
+// error answer OR a throw) or a failed read back shows a card listing the
+// objects that now exist; nothing switches path silently.
+import crypto from 'node:crypto';
+import { auditLog } from '@cspeach/sap-client';
+import { registerTool } from '../index.js';
+import fsp from 'node:fs/promises';
+import nodePath from 'node:path';
+import { planPinRoots } from '../../projects/plan-lane.js';
+import { getActivePlanPath } from '../../commands/plan-gate.js';
+import { cardLine } from '../../lane/card.js';
+import { readSkeletonDecision } from '../../rap/skeleton-store.js';
+import { verifyAndSpendApprovalId } from '../../approvals/jwt.js';
+import { grantClaimMismatch } from '../../approvals/grant-claims.js';
+import { checkTransportFit } from '../transport-fit-check.js';
+import { appendPending, finalizeToolCall } from '../../session/pending.js';
+import { noteWriteTransport } from '../../repl/current-transport.js';
+import { askConfirm } from '../../ui/confirm-request.js';
+import { cardSlotEmitter } from '../../ui/card-slot.js';
+import { isHeadless } from '../../renderer/tty.js';
+const TS_FIELDS = [/:\s*abp_locinst_lastchange_tstmpl\b/i, /:\s*abp_lastchange_tstmpl\b/i];
+const REPLAN = 'Run /abap-plan again.';
+/** Fix round 1 (M3): said on every pre-write stop after the approvals were checked. */
+const SPENT = 'Your approvals for this run were used; you will be asked again.';
+const spent = (next) => `${next} ${SPENT}`;
+const NEXT_BY_CHOICE = {
+    'delete-retry': 'Delete them with sap_delete_object in this order (each asks for approval), then call sap_generate_objects again.',
+    'delete-switch': 'Delete them in this order, then re-run /abap-plan and choose the CSPeach writer on the skeleton card.',
+    stop: 'Stopped. Nothing else was changed.',
+};
+const code = (t) => String(t ?? '').toUpperCase().split('/')[0].trim();
+const up = (s) => String(s ?? '').trim().toUpperCase();
+const label = (o) => `${code(o.type)} ${o.name}`;
+const sameObj = (a, b) => code(a.type) === code(b.type) && up(a.name) === up(b.name);
+/** Spec §5: binding → service definition → DDLX → projection BDEF/view → behavior pool → root BDEF/view → draft table. */
+const REVERSE_ORDER = (n) => [
+    { type: 'SRVB', name: n.serviceBinding }, { type: 'SRVD', name: n.serviceDefinition },
+    { type: 'DDLX', name: n.projection }, { type: 'BDEF', name: n.projection }, { type: 'DDLS', name: n.projection },
+    { type: 'CLAS', name: n.behaviorPool }, { type: 'BDEF', name: n.root }, { type: 'DDLS', name: n.root },
+    { type: 'TABL', name: n.draftTable },
+];
+function failureCardRequest(created, why) {
+    return {
+        id: 'rap-generate-failed',
+        tag: 'SAFETY CHECK',
+        title: "SAP's generator did not finish",
+        facts: [cardLine(why), ...(created.length
+                ? [cardLine('These objects now exist:'), ...created.map((o) => cardLine(label(o)))]
+                : [cardLine('No objects were created.')]),
+            cardLine('They are new, so there is nothing to restore if they are deleted.')],
+        choices: [
+            { value: 'delete-retry', label: cardLine('Delete them and try again') },
+            { value: 'delete-switch', label: cardLine('Delete them and build with the CSPeach writer instead') },
+            { value: 'stop', label: cardLine('Leave them and stop') },
+        ],
+        initial: 2,
+    };
+}
+function defaultHeadless() {
+    return isHeadless() || cardSlotEmitter.listenerCount('confirm') === 0;
+}
+const errorResult = (error, message, next, extras = {}) => ({
+    content: JSON.stringify({ error, message, next, ...extras }),
+    is_error: true,
+});
+/**
+ * Final review M1 — the root the decision file is read from, resolved like the
+ * plan's lane file (projects/plan-lane.ts readPlanLane): the running plan's own
+ * root first, then the lane root for cwd. The first root that HAS the file
+ * decides; with none, the last (cwd's lane root) gives the usual "missing".
+ */
+async function decisionRoot(cwd, rel) {
+    const roots = await planPinRoots(cwd, getActivePlanPath() ?? undefined);
+    const norm = rel.replace(/\\/g, '/');
+    for (const root of roots.slice(0, -1)) {
+        if (await fsp.stat(nodePath.join(root, norm)).then(() => true, () => false))
+            return root;
+    }
+    return roots[roots.length - 1];
+}
+const errText = (e) => (e instanceof Error ? e.message : String(e)).slice(0, 300);
+export async function sapGenerateObjectsHandler(args, ctx, deps = {}) {
+    // ── 1. Decision file ──────────────────────────────────────────────────────
+    let rec;
+    {
+        let read;
+        try {
+            read = await readSkeletonDecision(await decisionRoot(ctx.cwd, String(args?.decisionPath ?? '')), String(args?.decisionPath ?? ''), String(args?.decisionSha256 ?? ''));
+        }
+        catch {
+            read = { ok: false, message: 'The skeleton decision file could not be read. Run /abap-plan again.' };
+        }
+        if (!read.ok)
+            return errorResult('decision_invalid', read.message, REPLAN);
+        rec = read.rec;
+    }
+    if (rec.decision?.by !== 'sap-generator' || !rec.content || !Array.isArray(rec.objects) || rec.objects.length === 0) {
+        return errorResult('not_generator_path', "This skeleton is built by the CSPeach writer, not SAP's generator.", 'Build the skeleton with the normal create tools, as the plan says.');
+    }
+    const effective = up(args?.transport) || up(ctx.currentTransport?.get()) || '';
+    // ── 2. Approvals: one per planned object, same order ─────────────────────
+    const ids = Array.isArray(args?.approval_ids) ? args.approval_ids.map((x) => String(x ?? '')) : [];
+    if (ids.length !== rec.objects.length) {
+        return errorResult('approval_invalid', `${rec.objects.length} approvals are needed, one for each planned object. ${ids.length} were given.`, 'Request one create approval per planned object, in the plan order, then call this again.');
+    }
+    // One pass in order; stops at the first failure. A partly spent set is fine:
+    // no SAP write has happened and the run stops.
+    const payloads = [];
+    for (let i = 0; i < ids.length; i++) {
+        const o = rec.objects[i];
+        const v = await verifyAndSpendApprovalId(ids[i], o.name, 'create');
+        if (!v.ok) {
+            // Final review M6 — ids before this one were spent: ask for the whole set again, never just one.
+            return errorResult('approval_invalid', `The approval for ${label(o)} is not valid.`, spent('Request one create approval per planned object, in the plan order, then call this again.'), { reason: v.reason, object: label(o) });
+        }
+        payloads.push(v.payload);
+    }
+    for (let i = 0; i < payloads.length; i++) {
+        const o = rec.objects[i];
+        const claim = grantClaimMismatch(payloads[i], { type: o.type, package: rec.package, transport: effective || null });
+        if (claim) {
+            return errorResult('approval_invalid', `The approval for ${label(o)} does not match this write.`, spent("Request one create approval per planned object on the plan's transport, in the plan order, then call this again."), { reason: claim, object: label(o) });
+        }
+    }
+    // ── 3. Transport ──────────────────────────────────────────────────────────
+    if (!effective) {
+        return errorResult('transport_missing', 'No transport is set for this write.', spent('Pass the plan\'s transport, or set one with /transport, then call this again.'));
+    }
+    const fit = await checkTransportFit(ctx.adt, { type: 'DDLS', name: rec.names.root, pkg: rec.package, transport: effective });
+    if (!fit.ok)
+        return { content: JSON.stringify({ ...fit.refusal, next: SPENT }), is_error: true };
+    // ── 4–7. SAP reads before the write. A read that throws stops cleanly. ────
+    const tableUri = `/sap/bc/adt/ddic/tables/${rec.table.toLowerCase()}`;
+    let entry;
+    try {
+        // 4. Table is ready.
+        let src = null;
+        try {
+            src = await ctx.adt.getSource('TABL', rec.table);
+        }
+        catch (e) {
+            if (e?.httpStatus !== 404)
+                throw e;
+        }
+        if (src === null || !TS_FIELDS.every((re) => re.test(src))) {
+            return errorResult('table_not_ready', src === null
+                ? `Table ${rec.table} does not exist, so SAP's generator cannot run. Re-run /abap-plan: CSPeach will choose its own writer.`
+                : `Table ${rec.table} lacks the fields SAP's generator needs. Re-run /abap-plan: CSPeach will choose its own writer.`, spent('Re-run /abap-plan.'));
+        }
+        // 5. Generator entry.
+        const found = (await ctx.adt.listGenerators(tableUri)).find((g) => g.id === 'uiservice');
+        if (!found) {
+            return errorResult('generator_not_offered', `SAP's generator isn't offered for table ${rec.table}.`, spent('Re-run /abap-plan: CSPeach will choose its own writer.'));
+        }
+        entry = found;
+        // 6. Validate again (Review Focus 2) — before preview: preview does not check names.
+        const v = await ctx.adt.validateGenerator(entry, rec.content);
+        if (!v.ok) {
+            return errorResult('name_clash', `SAP's generator refused the planned names: ${cardLine(v.text || v.severity || 'no reason given')}`, spent('Choose new names: re-run /abap-plan. The object list changes, so you will approve it again.'));
+        }
+        // 7. Preview again (Review Focus 1).
+        const preview = (await ctx.adt.previewGenerator(entry, rec.content)).map((p) => ({ type: p.type, name: p.name }));
+        const missing = rec.objects.filter((o) => !preview.some((p) => sameObj(p, o)));
+        const extra = preview.filter((p) => !rec.objects.some((o) => sameObj(p, o)));
+        if (missing.length || extra.length) {
+            const parts = [
+                ...(missing.length ? [`Planned but not in SAP's preview: ${missing.map(label).join(', ')}.`] : []),
+                ...(extra.length ? [`In SAP's preview but not planned: ${extra.map(label).join(', ')}.`] : []),
+            ];
+            return errorResult('preview_differs', `SAP's generator would not build what the plan lists. ${parts.join(' ')}`, spent('Re-run /abap-plan. The object list changes, so you will approve it again.'), { missing: missing.map((o) => ({ type: code(o.type), name: o.name })), extra: extra.map((o) => ({ type: code(o.type), name: o.name })) });
+        }
+    }
+    catch (e) {
+        return errorResult('sap_read_failed', `Could not read from SAP before generating: ${cardLine(errText(e))}. Nothing was changed.`, spent('Check the connection to SAP, then call this again.'));
+    }
+    // ── 8. Write-ahead entry ──────────────────────────────────────────────────
+    const toolUseId = ctx.toolUseId ?? crypto.randomUUID();
+    const startedAt = Date.now();
+    await appendPending(ctx.session, {
+        tool_use_id: toolUseId,
+        tool: 'sap_generate_objects',
+        args: { decisionPath: String(args.decisionPath), table: rec.table, package: rec.package, transport: effective },
+        started_at: new Date().toISOString(),
+    });
+    const planned = rec.objects.map((o) => ({ type: code(o.type), name: o.name }));
+    const inDeleteOrder = (created) => REVERSE_ORDER(rec.names).filter((r) => created.some((c) => sameObj(c, r)));
+    /** Card (or headless stop), finalize, error result. */
+    const failWithCard = async (error, message, created, extras = {}) => {
+        let choice = 'stop';
+        if (!(deps.headless ?? defaultHeadless)()) {
+            try {
+                const res = await (deps.confirm ?? ((r) => askConfirm(r)))(failureCardRequest(created, message));
+                if (res.value === 'delete-retry' || res.value === 'delete-switch')
+                    choice = res.value;
+            }
+            catch {
+                choice = 'stop';
+            }
+        }
+        const out = errorResult(error, message, NEXT_BY_CHOICE[choice], { created, delete_in_order: inDeleteOrder(created), choice, ...extras });
+        // Fix round 1 (M2): every stop after the pending entry leaves an error row.
+        await auditLog('generateObjects', 'GENR', rec.names.root, 'error', Date.now() - startedAt, `${error} created=${created.length} transport=${effective}`);
+        await finalizeToolCall(ctx.session, toolUseId, out.content, true, Date.now() - startedAt);
+        return out;
+    };
+    /** Which planned objects exist: exact name AND the planned type code (M4: an SRVD hit is not the SRVB). */
+    const findExisting = async () => {
+        const found = [];
+        const unchecked = [];
+        for (const o of planned) {
+            try {
+                const hits = await ctx.adt.searchObject(o.name, o.type, 5);
+                if (hits.some((h) => up(h.name) === up(o.name) && code(h.type) === o.type))
+                    found.push(o);
+            }
+            catch {
+                unchecked.push(o);
+            }
+        }
+        return { found, unchecked };
+    };
+    // ── 9. Generate. An error answer and a throw are handled the same way. ───
+    let failure = null;
+    try {
+        const run = await ctx.adt.runGenerator(entry, rec.content, effective);
+        if (!(run.status >= 200 && run.status < 300))
+            failure = run.error || `SAP answered HTTP ${run.status}.`;
+    }
+    catch (e) {
+        failure = `The request to SAP failed: ${errText(e)}`;
+    }
+    if (failure !== null) {
+        // Which planned objects now exist (exact name, same type)?
+        const { found: created, unchecked } = await findExisting();
+        const note = unchecked.length ? ` Could not check: ${unchecked.map(label).join(', ')}.` : '';
+        return failWithCard('generate_failed', `SAP's generator failed. ${cardLine(failure)}${note}`, created, unchecked.length ? { unchecked } : {});
+    }
+    // ── 10. Read back: every object exists, is active and is on the plan's transport (spec §5 step 6).
+    {
+        const { found, unchecked } = await findExisting();
+        if (unchecked.length) {
+            return failWithCard('readback_failed', `The objects were generated, but CSPeach could not check that these exist: ${unchecked.map(label).join(', ')}.`, planned);
+        }
+        const missing = planned.filter((o) => !found.some((f) => sameObj(f, o)));
+        if (missing.length) {
+            return failWithCard('missing_after_generate', `SAP's generator reported success, but these objects do not exist: ${missing.map(label).join(', ')}.`, found, { missing });
+        }
+    }
+    try {
+        const inactive = await ctx.adt.inactiveObjects();
+        const stillInactive = planned.filter((o) => inactive.some((i) => sameObj(i, o)));
+        if (stillInactive.length) {
+            return failWithCard('inactive_after_generate', `SAP's generator left these objects inactive: ${stillInactive.map(label).join(', ')}.`, planned, { inactive: stillInactive });
+        }
+        const wrong = [];
+        const capped = [];
+        for (const o of planned) {
+            const t = await ctx.adt.transportForObject(o.type, o.name);
+            const candidates = (Array.isArray(t.candidates) ? t.candidates : []).map(up);
+            if (t.capped)
+                capped.push(o);
+            else if (t.transport && up(t.transport) !== effective)
+                wrong.push({ ...o, transport: up(t.transport) });
+            // Split ownership (M1): no single owner, and the plan's request is not among the owners.
+            else if (!t.transport && candidates.length && !candidates.includes(effective))
+                wrong.push({ ...o, transport: candidates.join(', ') });
+            // Null with no candidates: in no open request; existence was proven above.
+        }
+        if (capped.length) {
+            return failWithCard('readback_failed', `The objects were generated, but CSPeach could not check the transport of: ${capped.map(label).join(', ')}.`, planned);
+        }
+        if (wrong.length) {
+            return failWithCard('wrong_transport', `These objects landed on another transport, not ${effective}: ${wrong.map((w) => `${label(w)} on ${w.transport}`).join(', ')}.`, planned, { wrong });
+        }
+    }
+    catch (e) {
+        return failWithCard('readback_failed', `The objects were generated, but CSPeach could not check them: ${cardLine(errText(e))}`, planned);
+    }
+    // ── 11. Finish up ─────────────────────────────────────────────────────────
+    await auditLog('generateObjects', 'GENR', rec.names.root, 'success', Date.now() - startedAt, `generator=uiservice objects=${planned.length} transport=${effective}`);
+    noteWriteTransport(effective);
+    const result = JSON.stringify({ generated: true, objects: planned, transport: effective, next: 'finish' });
+    await finalizeToolCall(ctx.session, toolUseId, result, false, Date.now() - startedAt);
+    return { content: result };
+}
+registerTool({
+    name: 'sap_generate_objects',
+    description: "Run SAP's RAP generator for a skeleton phase whose Plan block says sap-generator. Pass the decision path and "
+        + 'sha256 from the plan block, and one approval_id per planned object in the same order (request_approval with '
+        + 'op create for each). CSPeach validates, previews, generates, then checks every object is active and on the '
+        + 'transport. Never call it for a CSPeach-writer skeleton.',
+    isMutating: true,
+    requiresSap: true,
+    input_schema: {
+        type: 'object',
+        properties: {
+            decisionPath: { type: 'string', description: 'Skeleton decision path from the Plan block' },
+            decisionSha256: { type: 'string', description: 'Skeleton decision sha256 from the Plan block' },
+            approval_ids: {
+                type: 'array', items: { type: 'string' },
+                description: 'One create approval id per planned object, in the plan order',
+            },
+            transport: { type: 'string', description: "The plan's transport (optional: defaults to the session transport)" },
+        },
+        required: ['decisionPath', 'decisionSha256', 'approval_ids'],
+    },
+    handler: (args, ctx) => sapGenerateObjectsHandler(args, ctx),
+});