@cspeach/cli 1.1.23 → 1.1.24

package/dist/lane/app-flow.js

@@ -0,0 +1,55 @@
+const flows = new WeakMap();
+/** Start (or restart) the flow for this session. A restart drops earlier state. */
+export function startAppFlow(session, specToken) {
+    flows.set(session, { specToken, expect: 'spec-gap' });
+}
+/** A frozen copy: callers change state only through the setters below. */
+export function getAppFlow(session) {
+    const f = flows.get(session);
+    if (!f)
+        return undefined;
+    const copy = { specToken: f.specToken, expect: f.expect };
+    if (f.specGapPath !== undefined)
+        copy.specGapPath = f.specGapPath;
+    if (f.lane)
+        copy.lane = Object.freeze({ ...f.lane });
+    if (f.queued !== undefined)
+        copy.queued = f.queued;
+    if (f.gapConfirmed !== undefined)
+        copy.gapConfirmed = f.gapConfirmed;
+    return Object.freeze(copy);
+}
+/** The spec-gap is saved: the lane step is next. No-op when no flow was started. */
+export function setSpecGap(session, path, queued) {
+    const f = flows.get(session);
+    if (!f)
+        return;
+    f.specGapPath = path;
+    f.expect = 'lane';
+    if (queued !== undefined)
+        f.queued = queued;
+    else
+        delete f.queued;
+}
+/** The lane is decided: the plan step is next. No-op when no flow was started. */
+export function setLane(session, path, sha256, queued) {
+    const f = flows.get(session);
+    if (!f)
+        return;
+    f.lane = { path, sha256 };
+    f.expect = 'plan';
+    if (queued !== undefined)
+        f.queued = queued;
+    else
+        delete f.queued;
+}
+/** M4 — record that the open-items question was confirmed for this spec-gap file. */
+export function setGapConfirmed(session, path) {
+    const f = flows.get(session);
+    if (!f)
+        return;
+    f.gapConfirmed = path;
+}
+export function clearAppFlow(session) {
+    flows.delete(session);
+}

package/dist/lane/card.js

@@ -0,0 +1,148 @@
+import { DEFAULT_RAP_REASON, READ_ONLY_ANALYTICAL_REASON, UNVERIFIED_REASON } from './resolve.js';
+import { SIGNAL_KEYS } from './signals.js';
+const MAX_LINE = 300;
+/**
+ * Control characters (C0, DEL, C1) and bidi / invisible format characters
+ * (soft hyphen, CGJ, ALM, Mongolian vowel separator, zero-width, LRM/RLM, line/para
+ * separators, embeddings/overrides, isolates, BOM, interlinear annotation, tag characters).
+ */
+// eslint-disable-next-line no-control-regex
+const UNSAFE = /[\u{0000}-\u{001F}\u{007F}-\u{009F}\u{00AD}\u{034F}\u{061C}\u{180E}\u{200B}-\u{200F}\u{2028}-\u{202E}\u{2060}-\u{2069}\u{FEFF}\u{FFF9}-\u{FFFB}\u{E0000}-\u{E007F}]/gu;
+/** Strip unsafe characters and cap the line at 300 characters (code points). */
+export function cardLine(text) {
+    const clean = text.replace(UNSAFE, '');
+    const chars = Array.from(clean);
+    return chars.length <= MAX_LINE ? clean : `${chars.slice(0, MAX_LINE - 1).join('')}\u2026`;
+}
+/**
+ * `@<path>` for a plain line the user reads (never a queued command): quoted
+ * when it has whitespace, `<placeholder>` when it cannot be shown as a token.
+ */
+export function shownToken(p, placeholder) {
+    const t = p === undefined ? '' : cardLine(p).trim();
+    if (t === '' || t.includes('"'))
+        return `@<${placeholder}>`;
+    return /\s/.test(t) ? `@"${t}"` : `@${t}`;
+}
+/** I4(c) — headless / one-shot: no app flow survives the process, so the chain must be run interactively. */
+export function interactiveRunLine(specToken) {
+    return `Run /abap-app ${shownToken(specToken, 'spec file')} in an interactive cspeach session to build with the lane card.`;
+}
+const BACKEND_LABEL = {
+    rap: 'on-stack RAP',
+    cap: 'CAP (side-by-side)',
+    none: 'UI only',
+    'abap-report': 'classic report',
+    segw: 'SEGW',
+    'bopf-generated': 'BOPF-generated',
+};
+const UI_LABEL = {
+    'fiori-elements': 'Fiori Elements',
+    freestyle: 'freestyle UI5',
+    none: '',
+};
+const HINT_WORDS = {
+    cap_external_users: 'users outside SAP',
+    cap_multi_system: 'data from several systems',
+    cap_own_release_cycle: 'its own release cycle',
+    cap_ui_on_released_api: 'mostly UI and logic on a released SAP API',
+};
+const hintWords = (k) => HINT_WORDS[k] ?? k.replace(/_/g, ' ');
+const SIGNAL_WORDS = {
+    ...HINT_WORDS,
+    app_requested: 'an app is asked for',
+    ui_only_service: 'a UI on a published service',
+    report_only: 'list output only',
+    analytical: 'charts or KPIs',
+    transactional: 'create, change or delete',
+    custom_ui: 'a custom UI',
+};
+/**
+ * One card line per claimed signal (truthy value) with no evidence quote, or
+ * whose quote was not found word for word in the spec: it was downgraded to
+ * weak (spec §8, Review Focus 1). Pure; lines are sanitised and capped.
+ */
+export function quoteNotFoundFacts(signals) {
+    const out = [];
+    for (const k of SIGNAL_KEYS) {
+        const s = signals[k];
+        const claimed = typeof s.value === 'string' ? s.value.trim() !== '' : s.value === true;
+        if (!claimed || s.quoteFound)
+            continue;
+        const why = (s.evidence ?? '').trim() === '' ? 'no quote given' : 'quote not found';
+        out.push(cardLine(`Weak signal, ${why}: ${SIGNAL_WORDS[k] ?? k}`));
+    }
+    return out;
+}
+const NEUTRAL_DEFAULT = 'No strong signal. Default is on-stack RAP + Fiori Elements.';
+const NEUTRAL_ANALYTICAL = 'No strong side-by-side signal. Recommended: on-stack RAP with an analytical app (ALP).';
+function laneName(backend, ui) {
+    const u = UI_LABEL[ui];
+    return u ? `${BACKEND_LABEL[backend]} + ${u}` : BACKEND_LABEL[backend];
+}
+function decidedByLine(d) {
+    const path = d.decidedByPath ?? 'unknown file';
+    if (d.decidedBy === 'pin')
+        return `Decided by: project pin (${path})`;
+    if (d.decidedBy === 'standards')
+        return `Decided by: standards file (${path})`;
+    if (d.decidedBy === 'developer')
+        return 'Decided by: the developer';
+    return 'Decided by: the spec and the rules';
+}
+/** The lane card. Pure: builds the request from the decision, never mutates it. */
+export function laneCardRequest(decision) {
+    // Card-only de-duplication: the neutral line restates the default, the
+    // "System not checked." line restates the unverified reason. The decision is untouched.
+    const reasons = decision.reasons.filter((r) => !(decision.neutral && r === DEFAULT_RAP_REASON) && !(decision.unverified && r === UNVERIFIED_REASON));
+    const facts = [...reasons, decidedByLine(decision)];
+    if (decision.neutral) {
+        const analytical = decision.reasons.includes(READ_ONLY_ANALYTICAL_REASON);
+        facts.push(analytical ? NEUTRAL_ANALYTICAL : NEUTRAL_DEFAULT);
+        if (decision.weakHints.length > 0) {
+            facts.push(`Weak hints toward CAP: ${decision.weakHints.map(hintWords).join(', ')}`);
+        }
+    }
+    for (const c of decision.crossedOut)
+        facts.push(`✗ ${BACKEND_LABEL[c.lane] ?? c.lane}: ${c.reason}`);
+    if (decision.unverified)
+        facts.push('System not checked.');
+    const choices = [];
+    const allowed = [...new Set(decision.allowed)];
+    const recommended = !decision.noAppLane && decision.backend && allowed.includes(decision.backend) ? decision.backend : null;
+    if (recommended) {
+        choices.push({ value: 'confirm', label: `Use ${laneName(recommended, decision.ui)}` });
+    }
+    for (const lane of allowed) {
+        if (lane === recommended)
+            continue;
+        choices.push({ value: `switch:${lane}`, label: `Switch to ${BACKEND_LABEL[lane]}` });
+    }
+    choices.push({ value: 'cancel', label: 'Cancel' });
+    const title = recommended
+        ? `Build lane: ${laneName(recommended, decision.ui)}`
+        : 'No app lane is available on this system';
+    return {
+        id: 'app-lane',
+        tag: 'QUESTION',
+        title: cardLine(title),
+        facts: facts.map(cardLine),
+        choices: choices.map((c) => ({ ...c, label: cardLine(c.label) })),
+        initial: 0,
+    };
+}
+/** The runtime card for a CAP lane whose runtime is not known yet. Pure. */
+export function runtimeCardRequest() {
+    return {
+        id: 'app-lane-runtime',
+        tag: 'QUESTION',
+        title: 'Where will this CAP app run?',
+        choices: [
+            { value: 'btp', label: 'SAP BTP' },
+            { value: 'own-server', label: 'Our own server' },
+            { value: 'none', label: "Only on the developer's laptop for now" },
+        ],
+        initial: 0,
+        footnote: 'Saved to .cspeach/conventions.toml',
+    };
+}

package/dist/lane/chain-token.js

@@ -0,0 +1,59 @@
+// Task 7 review round 1, R10 — the ONE place that turns the session's saved
+// spec-gap path into the `@<path>` token of a queued `--from` command. Used by
+// afterSpecGapSave (`/abap-app --from …`) and app_lane_resolve
+// (`/abap-plan --from …`), so the two can never disagree about the save root.
+//
+// Input is CLI state only (the app flow's specGapPath, from the save hook),
+// never a tool argument. Refused (undefined) unless:
+// - the name is a saved spec-gap envelope (projectFilename shape, with the
+//   optional `-N` collision suffix saveProject adds);
+// - the path has no `"` and no control character (it rides in a command);
+// - the real file exists inside realpath(cwd) or realpath(workspace folder),
+//   so a link out of the save root is refused.
+// Round trip: parseFromFlag reads `@"…"` / `@\S+`; resolveAtTokenAsync takes a
+// path with a separator or an absolute path verbatim; coerceDocFromFlagToAttachment
+// leaves `.cspeach.json` alone.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { assertRealPathContained } from '../tools/_filesystem-shared.js';
+import { workspaceFolderFor } from './roots.js';
+/** `<slug>-spec-gap-<4 hex>-v<N>[-<n>].cspeach.json` — titleSlug is `[a-z0-9-]`, possibly empty. */
+export const SPEC_GAP_NAME_RE = /^[a-z0-9-]*-spec-gap-[0-9a-f]{4}-v\d+(?:-\d+)?\.cspeach\.json$/;
+// eslint-disable-next-line no-control-regex
+const UNSAFE = /["\u0000-\u001f\u007f-\u009f]/;
+/** A segment after whitespace (or at the start) that begins with `--`. */
+const FLAG_LIKE = /(?:^|\s)--/;
+async function containedIn(abs, root) {
+    if (!root)
+        return false;
+    try {
+        const realRoot = await fs.realpath(root);
+        await assertRealPathContained(abs, realRoot);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function chainFromToken(cwd, savedPath) {
+    if (typeof savedPath !== 'string' || savedPath.trim() === '' || UNSAFE.test(savedPath))
+        return undefined;
+    if (!SPEC_GAP_NAME_RE.test(path.basename(savedPath)))
+        return undefined;
+    const root = path.resolve(cwd);
+    const abs = path.resolve(root, savedPath);
+    if (UNSAFE.test(abs))
+        return undefined;
+    const ws = await workspaceFolderFor(cwd).catch(() => undefined);
+    if (!(await containedIn(abs, root)) && !(await containedIn(abs, ws)))
+        return undefined;
+    const rel = path.relative(root, abs);
+    let p = rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel.split(path.sep).join('/') : abs;
+    if (!path.isAbsolute(p) && !p.includes('/'))
+        p = `./${p}`;
+    // Review round 2 — a whitespace-separated piece that looks like a flag
+    // (`w --resume --guarded`) would be read as one by quote-unaware parsers.
+    if (FLAG_LIKE.test(p) || FLAG_LIKE.test(abs))
+        return undefined;
+    return { token: /\s/.test(p) ? `@"${p}"` : `@${p}`, path: p };
+}