@cspeach/cli 1.1.29 → 1.1.31

package/dist/journey/run.js

@@ -0,0 +1,435 @@
+/**
+ * Guided clean-core journey, Task 2 — run one stage
+ * (design .superpowers/sdd/guided-journey-design.md §1, §2, §4).
+ *
+ * The code stages run the `team` command bodies in process, their output kept
+ * back, and say a few plain lines of their own. The model stages (DECIDE, FIX)
+ * are not run here: the runner builds the slash command from the register and
+ * hands it back for the loop to queue. Nothing here touches the REPL or the
+ * loop, nothing throws, and every path returns lines plus the next action.
+ *
+ * Solo words only on screen: never "team", "lane", "outbox" or "join" — except
+ * inside a slash command the journey queues or names.
+ */
+import path from 'node:path';
+import { estateSummaryOf, usageLineWithWindow } from '@cspeach/register-core';
+import { runTeamCommand, whoAmI, writeReports } from '../commands/team.js';
+import { shown, shownUpTo } from '../register/atc-file.js';
+import { activeProject, readEstate, readLanes, readProjectFile } from '../register/store.js';
+import { claimedSinceCheck, fixFailedCheck, myObjects, readJourneyFacts, stepOf, toDecide, toFix, toProve, toRedesign, unreadableReason, STEPS, } from './clean-core.js';
+/* ── words ──────────────────────────────────────────────────────────────── */
+export const UNREADABLE_LINES = {
+    'object-list': 'The project\'s object list in this folder can\'t be read right now — it may still be syncing. Try again in a minute.',
+    'project-file': 'This folder\'s project file can\'t be read.',
+    other: 'This folder can\'t be read right now.',
+};
+const step = (stage, title) => `Step ${stepOf(stage)} of ${STEPS} — ${title}`;
+const plural = (count, one, many) => `${count.toLocaleString('en-US')} ${count === 1 ? one : many}`;
+const minutes = (objects) => {
+    // About 25 objects a minute (live measurement 2026-10-07), never under one minute.
+    const m = Math.max(1, Math.ceil(objects / 25));
+    return `About ${plural(m, 'minute', 'minutes')}.`;
+};
+/** Words a solo person never reads, and anything that looks like a path or a command to type. */
+const NOT_SOLO = /\b(team|lanes?|outbox(es)?|join(s|ed|ing)?|writers?|variant|projectId|claim(s|ed|ing)?)\b/i;
+// Unix paths bare, quoted or bracketed ('/Users/x/y.json'), and home paths (~/x).
+const LOOKS_LIKE_PATH = /[A-Za-z]:\\|\\\\|(^|[\s"'`(])\/[^\s"'`)]*\/|~\/|cspeach\s/i;
+export const NO_SAP_LINE = 'No SAP system is connected in this session.';
+const NO_ATC_LINE = "SAP's code checks can't be run from this session.";
+const ALREADY_LINE = 'This folder already holds a project. Say carry on to work in it.';
+/**
+ * The failures CSPeach knows, each in its own plain words. "Cannot measure"
+ * comes first: a session without SAP is said before any step runs, so here it
+ * means the connection offers no ATC.
+ */
+const KNOWN = [
+    [/cannot measure/i, NO_ATC_LINE],
+    [/No SAP system is configured|needs a SAP connection/i, NO_SAP_LINE],
+    [/already holds a team project/i, ALREADY_LINE],
+];
+/**
+ * What to say when a team body failed: a known failure in its own words;
+ * else its first error, when that reads as a plain sentence; else `fallback`.
+ * Never a path, never a word a solo person does not use.
+ */
+export function failureLine(said, fallback) {
+    for (const line of said)
+        for (const [re, words] of KNOWN)
+            if (re.test(line))
+                return words;
+    const first = said.find((l) => l.startsWith('✗'))?.replace(/^✗\s*/, '').trim();
+    if (!first || NOT_SOLO.test(first) || LOOKS_LIKE_PATH.test(first))
+        return fallback;
+    return shown(first);
+}
+const failure = failureLine;
+/**
+ * A decision record that could not be written, inside a journey: "Not
+ * recorded: <plain reason>." The reason as it was said when it reads as a
+ * plain sentence; never a path, a team word or a command.
+ */
+export function notRecordedLine(error) {
+    const said = error instanceof Error ? error.message : String(error);
+    const plain = failureLine([`✗ ${said}`], 'the record could not be written to this folder').replace(/[\s.…]+$/, '');
+    return `Not recorded: ${plain}.`;
+}
+/** An object name to show: as it is when it is an ABAP name, cleaned otherwise. */
+export const objectShown = (name) => (OBJECT_NAME.test(name.toUpperCase()) ? name.toUpperCase() : shown(name));
+/** An object marked fix whose name CSPeach never puts in a command: one plain line, and it is passed over. */
+export const passedOverLine = (name) => `${objectShown(name)}: the name is not an ABAP name, so CSPeach passed it over.`;
+/* ── commands the journey queues ────────────────────────────────────────── */
+const OBJECT_TYPE = /^[A-Z]{4}$/;
+/** An ABAP object name: letters, digits, underscores, an optional /NAMESPACE/ in front. */
+const OBJECT_NAME = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,40}$/;
+const LANE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/;
+export const MAX_REASON = 300;
+const chars = (...codes) => String.fromCharCode(...codes);
+/** Straight, back and curly quotes. */
+const QUOTES = new RegExp(`["'${chars(0x60, 0x2018, 0x2019, 0x201c, 0x201d)}]`, 'g');
+/** Bidi isolates and the Arabic letter mark (shown() already drops the other bidi and zero-width characters). */
+const ISOLATES = new RegExp(`[${chars(0x61c, 0x2066, 0x2067, 0x2068, 0x2069)}]`, 'g');
+/** Dashes and the minus: the command holds exactly one " — ", the one before the reason. */
+const DASHES = new RegExp(`[${chars(0x2010, 0x2011, 0x2012, 0x2013, 0x2014, 0x2015, 0x2212)}]`, 'g');
+/** A word that would be read as an image to attach (the turn attaches typed image paths). */
+const IMAGE_WORD = /\.(png|jpe?g|gif|webp)\b/gi;
+/**
+ * A recorded reason as the person wrote it, for a card: escape sequences,
+ * control, zero-width and bidi characters gone, at most `max` characters.
+ * Not the command text — that is cleanReason().
+ */
+export function shownReason(reason, max) {
+    return shownUpTo(String(reason ?? '').replace(ISOLATES, ''), max);
+}
+/**
+ * A reason as one plain line for the queued command: escape sequences,
+ * control, zero-width and bidi characters gone (shown()); no quotes; no
+ * dashes but a plain hyphen; and nothing the turn would act on — no `@`
+ * (a file to attach), no `--` (a flag such as --from), no `[ ]` (an image
+ * chip), no image file name. At most 300 characters.
+ */
+export function cleanReason(reason) {
+    return shownUpTo(String(reason ?? '').replace(ISOLATES, ''), Number.MAX_SAFE_INTEGER)
+        .replace(QUOTES, '')
+        .replace(DASHES, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/@/g, ' ')
+        .replace(/\[/g, '(')
+        .replace(/\]/g, ')')
+        .replace(IMAGE_WORD, ' $1')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, MAX_REASON)
+        .trim();
+}
+/** `/abap-clean-core triage lane <id>`, or null when the id is not one CSPeach passes on. */
+export function triageCommand(laneId) {
+    return LANE_ID.test(laneId) ? `/abap-clean-core triage lane ${laneId}` : null;
+}
+/** `/abap-refactor <TYPE> <NAME> — <reason>`, names upper-cased; null when a name is not an ABAP name. */
+export function refactorCommand(o) {
+    const type = o.type.trim().toUpperCase();
+    const name = o.name.trim().toUpperCase();
+    if (!OBJECT_TYPE.test(type) || !OBJECT_NAME.test(name))
+        return null;
+    const reason = cleanReason(o.reason);
+    return `/abap-refactor ${type} ${name}${reason ? ` — ${reason}` : ''}`;
+}
+/* ── the runner ─────────────────────────────────────────────────────────── */
+const result = (stage, lines, next, skip) => ({ stage, lines, next, ...(skip ? { skip } : {}) });
+/** A package name typed in full: no pattern, nothing that is not a package name. */
+const PACKAGE = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,30}$/;
+const IS_PATTERN = /[*?%]/;
+/**
+ * Run one stage. Never throws: anything unexpected comes back as one plain
+ * line and a stop. Headless runs nothing and queues nothing; it says the next step.
+ */
+export async function runJourneyStage(stage, ctx) {
+    try {
+        if (ctx.headless)
+            return nextStepOnly(stage, ctx);
+        // Said before any card: a step that needs SAP, in a session without one.
+        if (ctx.team.deps.noSap && (stage === 'INVENTORY' || stage === 'START' || stage === 'PROVE'))
+            return result(stage, [NO_SAP_LINE], { kind: 'stop' });
+        switch (stage) {
+            case 'UNREADABLE': return result(stage, [UNREADABLE_LINES[unreadableReason(facts(ctx)) ?? 'other']], { kind: 'stop' });
+            case 'INVENTORY': return await inventory(ctx);
+            case 'START': return await start(ctx);
+            case 'JOIN': return await joinStage(ctx);
+            case 'DECIDE': return decideStage(ctx);
+            case 'FIX': return fixStage(ctx);
+            case 'PROVE': return await prove(ctx);
+            case 'REPORT': return await report(ctx);
+            case 'DONE': return done(ctx);
+        }
+    }
+    catch (e) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        const said = [`✗ ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`];
+        return result(stage, [failure(said, 'This step could not finish.')], { kind: 'stop' });
+    }
+}
+const me = (ctx) => whoAmI(ctx.team.deps);
+const facts = (ctx) => readJourneyFacts(ctx.cwd, me(ctx), ctx.skips);
+/** Run a team body with its output kept back; `said` holds only this run's lines. */
+async function quiet(ctx, args) {
+    const { said } = ctx.team;
+    said.length = 0;
+    const code = await runTeamCommand(args, ctx.team.deps);
+    return { code, said: [...said] };
+}
+/** Headless / one-shot: the next step in words, nothing run, nothing queued. */
+function nextStepOnly(stage, ctx) {
+    const stop = (line) => result(stage, [line], { kind: 'stop' });
+    switch (stage) {
+        case 'UNREADABLE': return stop(UNREADABLE_LINES[unreadableReason(facts(ctx)) ?? 'other']);
+        case 'INVENTORY': return stop(`Next: ${step(stage, 'look at what custom code is on the system.')}`);
+        case 'START': {
+            const named = (ctx.packages ?? []).map((p) => p.trim().toUpperCase()).filter((p) => PACKAGE.test(p));
+            return stop(`Next: ${step(stage, `start your project${named.length ? ` on ${named.join(', ')}` : ''} in this folder.`)}`);
+        }
+        case 'JOIN': return stop(`Next: ${step(stage, 'pick up the project in this folder.')}`);
+        case 'DECIDE':
+        case 'FIX': {
+            const r = stage === 'DECIDE' ? decideStage(ctx) : fixStage(ctx);
+            // Names passed over are still said; the step line gives way to the command.
+            return r.next.kind === 'queue'
+                ? result(stage, [...r.lines.filter((l) => !l.startsWith('Step ') && !l.startsWith('  ')), `Next: ${r.next.command}`], { kind: 'stop' }, r.skip)
+                : r;
+        }
+        case 'PROVE': return stop(`Next: ${step(stage, 'let SAP check your fixes.')}`);
+        case 'REPORT': return stop(`Next: ${step(stage, 'make the status page.')}`);
+        case 'DONE': return done(ctx);
+    }
+}
+/* INVENTORY — what is out there. */
+async function inventory(ctx) {
+    const { code, said } = await quiet(ctx, ['discover', '--out', ctx.cwd]);
+    const found = code === 0 ? readEstate(ctx.cwd) : null;
+    const s = found ? estateSummaryOf(found.estate) : null;
+    if (!s)
+        return result('INVENTORY', [failure(said, 'The system could not be read.')], { kind: 'stop' });
+    const t = s.totals;
+    const words = [
+        `${plural(t.packages, 'package', 'packages')} with ${plural(t.codeObjects, 'code object', 'code objects')}.`,
+        ...(t.modifications ? [`${plural(t.modifications, 'change', 'changes')} to SAP's own objects.`] : []),
+        usageLineWithWindow(s),
+    ];
+    return result('INVENTORY', [`${step('INVENTORY', 'what is out there.')} ${words.join(' ')}`], { kind: 'continue' });
+}
+/* START — the project on the named packages, in this folder. */
+async function start(ctx) {
+    const stop = (line) => result('START', [line], { kind: 'stop' });
+    const asked = (ctx.packages ?? []).map((p) => p.trim().toUpperCase()).filter(Boolean);
+    if (!asked.length)
+        return stop('Which package first? Say: start clean core on ZFI_AR.');
+    if (asked.some((p) => IS_PATTERN.test(p)))
+        return stop('Name each package in full, for example ZFI_AR — not a pattern.');
+    if (asked.some((p) => !PACKAGE.test(p)))
+        return stop('Name each package in full, for example ZFI_AR.');
+    const packages = [...new Set(asked)];
+    // Checked against the system's own package list when the folder holds one.
+    const found = readEstate(ctx.cwd);
+    const known = found ? estateSummaryOf(found.estate)?.packages.map((p) => p.name.toUpperCase()) : undefined;
+    const unknown = known ? packages.filter((p) => !known.includes(p)) : [];
+    if (unknown.length)
+        return stop(`CSPeach did not find ${unknown.length === 1 ? 'the package' : 'the packages'} ${unknown.join(', ')} on the system.`);
+    const { code, said } = await quiet(ctx, ['start', ...packages, '--folder', ctx.cwd]);
+    if (code !== 0)
+        return stop(failure(said, 'The project could not be started.'));
+    let name = packages.join(', ');
+    try {
+        name = shown(readProjectFile(ctx.cwd).name);
+    }
+    catch { /* the name it was started with */ }
+    const objects = said.map((l) => /^\s*([\d,]+) objects?, matched against/.exec(l)?.[1]).find(Boolean);
+    const check = said.map((l) => /First check \([^)]*\): ([\d,]+) of ([\d,]+) objects? with findings/.exec(l)).find(Boolean);
+    const lines = [`✓ Your project on ${name} started here.`];
+    if (objects)
+        lines.push(`  ${objects} ${objects === '1' ? 'object' : 'objects'}, matched against the system's count.`);
+    lines.push(check ? `  First check: ${check[1]} of ${check[2]} objects with findings.` : '  No check yet.');
+    return result('START', lines, { kind: 'continue' });
+}
+/* JOIN — a project in this folder this laptop does not record into. */
+async function joinStage(ctx) {
+    const f = facts(ctx);
+    const folder = f.folder;
+    // Out of a synced file someone else may have written: cleaned before it is shown.
+    const lead = 'lead' in folder ? shown(folder.lead) : '';
+    const name = 'name' in folder ? shown(folder.name) : '';
+    if (folder.kind === 'unreadable')
+        return result('JOIN', [UNREADABLE_LINES[folder.reason]], { kind: 'stop' });
+    if (folder.kind !== 'mine-not-joined' && folder.kind !== 'someone-else')
+        return result('JOIN', [], { kind: 'continue' });
+    if (folder.kind === 'someone-else') {
+        const res = await ctx.team.confirm({
+            id: 'journey-join',
+            tag: 'QUESTION',
+            title: `This folder holds ${lead}'s project ${name}. Work in it?`,
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'yes', n: 'no' },
+        });
+        if (res.cancelled || res.value !== 'yes')
+            return result('JOIN', ['Nothing changed in this folder.'], { kind: 'stop' });
+    }
+    // Results go straight into the folder.
+    const { code, said } = await quiet(ctx, ['join', ctx.cwd, '--outbox', ctx.cwd]);
+    if (code !== 0)
+        return result('JOIN', [failure(said, 'The project in this folder could not be opened.')], { kind: 'stop' });
+    const line = folder.kind === 'mine-not-joined'
+        ? `Picking up your project on ${name}.`
+        : `✓ Working in ${lead}'s project ${name}.`;
+    return result('JOIN', [line], { kind: 'continue' });
+}
+/* DECIDE — the triage of my objects, a model step. */
+function decideStage(ctx) {
+    const f = facts(ctx);
+    const left = f.register ? toDecide(f.register, f.me, f.skip) : [];
+    const lane = left[0]?.lane;
+    const command = lane ? triageCommand(lane) : null;
+    if (!command)
+        return result('DECIDE', ['Nothing to decide that CSPeach can hand on.'], { kind: 'stop' });
+    return result('DECIDE', [`${step('DECIDE', 'decide what happens to each object.')} ${plural(left.length, 'object', 'objects')} to go.`], { kind: 'queue', command });
+}
+/* FIX — the next object to fix, a model step. */
+function fixStage(ctx) {
+    const f = facts(ctx);
+    const left = f.register ? toFix(f.register, f.me, f.skip) : [];
+    // A name that is not an ABAP name is passed over with one line; the next one is queued.
+    const passed = [];
+    for (const o of left) {
+        // The reason comes from the recorded decision only, never from the model's words.
+        const command = refactorCommand({ type: o.type, name: o.name, ...(o.decision?.reason ? { reason: o.decision.reason } : {}) });
+        if (!command) {
+            passed.push(o);
+            continue;
+        }
+        const lines = [...passed.map((x) => passedOverLine(x.name)), `${step('FIX', `fix ${o.name.toUpperCase()}.`)}`];
+        if (fixFailedCheck(o))
+            lines.push('  Its last fix failed the check.');
+        return result('FIX', lines, { kind: 'queue', command, key: o.key }, passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
+    }
+    return result('FIX', passed.map((x) => passedOverLine(x.name)), { kind: 'continue' }, passed.length ? { fix: new Set(passed.map((x) => x.key)) } : undefined);
+}
+/** What a check of my claimed fixes measures: my one area, or the packages of the claimed objects. */
+function proveScope(f, waiting) {
+    const r = f.register;
+    const joined = activeProject();
+    const lanes = joined ? readLanes(joined.projectDir).filter((l) => l.owner.trim().toLowerCase() === f.me.trim().toLowerCase()) : [];
+    if (lanes.length === 1)
+        return { args: ['refresh'], objects: myObjects(r, f.me).length };
+    const packages = [...new Set(waiting.map((o) => o.package))];
+    return {
+        args: ['refresh', '--packages', packages.join(',')],
+        objects: r.objects.filter((o) => o.inScope && packages.includes(o.package)).length,
+    };
+}
+/* PROVE — SAP checks the claimed fixes. */
+async function prove(ctx) {
+    const f = facts(ctx);
+    if (!f.register)
+        return result('PROVE', [UNREADABLE_LINES[unreadableReason(f) ?? 'other']], { kind: 'stop' });
+    const waiting = toProve(f.register, f.me);
+    if (!waiting.length)
+        return result('PROVE', [], { kind: 'continue' });
+    const scope = proveScope(f, waiting);
+    const res = await ctx.team.confirm({
+        id: 'journey-prove',
+        tag: 'QUESTION',
+        title: `Let SAP check your ${plural(scope.objects, 'object', 'objects')}? ${minutes(scope.objects)}`,
+        facts: ['Reads only. Nothing in SAP is changed.'],
+        choices: [{ value: 'yes', label: 'Yes' }, { value: 'later', label: 'Later' }],
+        initial: 0,
+        aliases: { y: 'yes', l: 'later' },
+    });
+    if (res.value === 'later' && !res.cancelled)
+        return result('PROVE', ['Left for later.'], { kind: 'continue' }, { prove: true });
+    if (res.cancelled || res.value !== 'yes')
+        return result('PROVE', ['Not checked.'], { kind: 'stop' });
+    const { said } = await quiet(ctx, scope.args);
+    const measured = said.map((l) => /^✓ ([\d,]+) objects? measured/.exec(l)?.[1]).find(Boolean);
+    const after = readJourneyFacts(ctx.cwd, f.me, ctx.skips).register;
+    const byKey = new Map((after?.objects ?? []).map((o) => [o.key, o]));
+    const lines = [];
+    for (const was of waiting) {
+        const now = byKey.get(was.key);
+        const name = objectShown(was.name);
+        if (!now || !now.lastMeasuredAt || now.lastMeasuredAt === was.lastMeasuredAt)
+            lines.push(`${name}: not checked yet.`);
+        else if (now.state === 'verified' || now.state === 'clean')
+            lines.push(`${name}: fix proven.`);
+        else if (fixFailedCheck(now) && !claimedSinceCheck(now))
+            lines.push(`${name}: fix failed the check.`);
+        else
+            lines.push(`${name}: not checked yet.`);
+    }
+    if (!measured && lines.every((l) => l.endsWith('not checked yet.'))) {
+        return result('PROVE', [failure(said, 'SAP could not check them right now.')], { kind: 'stop' });
+    }
+    return result('PROVE', [`✓ ${measured ?? waiting.length} checked.`, ...lines], { kind: 'continue' });
+}
+/* REPORT — the status page and the workbook, in reports/. */
+async function report(ctx) {
+    const joined = activeProject();
+    if (!joined)
+        return result('REPORT', [UNREADABLE_LINES.other], { kind: 'stop' });
+    const project = readProjectFile(joined.projectDir);
+    const mine = project.lead.name.trim().toLowerCase() === me(ctx).trim().toLowerCase();
+    // The status page of a shared folder is its lead's to make.
+    if (!mine)
+        return result('REPORT', [`The status page is made by ${shown(project.lead.name)}.`], { kind: 'continue' }, { report: true });
+    const { saved, held } = writeReports(joined.projectDir, project, path.join(joined.projectDir, 'reports'), ctx.team.deps);
+    const lines = [];
+    if (saved.length)
+        lines.push(`✓ Saved ${saved.map((n) => `"${n}"`).join(' and ')} in the reports folder.`);
+    for (const name of held)
+        lines.push(`  "${name}" is open in another program, so it was not updated. Close it and say carry on.`);
+    const page = saved.find((n) => n.toLowerCase().endsWith('.html'));
+    if (page) {
+        const res = await ctx.team.confirm({
+            id: 'journey-open-report',
+            tag: 'QUESTION',
+            title: 'Open the status page in your browser?',
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'yes', n: 'no' },
+        });
+        if (res.value === 'yes' && !res.cancelled) {
+            try {
+                const said = await ctx.openFile?.(path.join(joined.projectDir, 'reports', page));
+                if (Array.isArray(said))
+                    lines.push(...said);
+            }
+            catch {
+                lines.push('  Could not open the browser — open the page from the reports folder.');
+            }
+        }
+    }
+    return result('REPORT', lines, { kind: 'continue' }, { report: true });
+}
+/** The closing count of objects kept: "1 kept as is", "2 kept as they are". */
+export const keptPart = (n) => `${n} ${n === 1 ? 'kept as is' : 'kept as they are'}`;
+/* DONE — a short summary. */
+function done(ctx) {
+    const f = facts(ctx);
+    const lines = ['Done for now.'];
+    if (f.register) {
+        const mine = myObjects(f.register, f.me);
+        const count = (pred) => mine.filter(pred).length;
+        const parts = [
+            [count((o) => o.state === 'clean'), 'clean'],
+            [count((o) => o.state === 'verified'), 'fix proven'],
+        ].filter(([n]) => n > 0).map(([n, w]) => `${n} ${w}`);
+        const kept = count((o) => o.decision?.classification === 'keep' && o.state !== 'clean');
+        if (kept)
+            parts.push(keptPart(kept));
+        if (mine.length)
+            lines.push(`  ${plural(mine.length, 'object', 'objects')}${parts.length ? `: ${parts.join(', ')}` : ''}.`);
+        const rebuild = toRedesign(f.register, f.me).length;
+        if (rebuild)
+            lines.push(`  ${plural(rebuild, 'object', 'objects')} planned for a rebuild — handled separately.`);
+    }
+    lines.push('Next time, open CSPeach in this folder and say carry on.');
+    return result('DONE', lines, { kind: 'done' });
+}

package/dist/journey/session-deps.js

@@ -0,0 +1,77 @@
+import { activeProject } from '../register/store.js';
+const CANCELLED = { value: null, cancelled: true };
+/** The confirm card the session shows; headless never shows one. */
+export function journeyConfirm(headless, confirm) {
+    if (headless)
+        return async () => CANCELLED;
+    return confirm ?? (async (req) => {
+        const { askConfirm } = await import('../ui/confirm-request.js');
+        return askConfirm(req);
+    });
+}
+/**
+ * A team body's [y/n] question as a Yes/No card: 'y', 'n', or '' when the card
+ * was put away or nobody is there. A question that wants words (a variant
+ * name) gets '' without a card: a card cannot answer it, and '' assumes nothing.
+ */
+function askWith(confirm) {
+    let n = 0;
+    return async (question) => {
+        const yn = /\s*\[y\/n\]\s*$/i;
+        if (!yn.test(question))
+            return '';
+        const res = await confirm({
+            id: `journey-ask-${(n += 1)}`,
+            tag: 'QUESTION',
+            title: question.replace(yn, ''),
+            choices: [{ value: 'y', label: 'Yes' }, { value: 'n', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'y', n: 'n' },
+        });
+        return res.cancelled || res.value === null ? '' : res.value;
+    };
+}
+/** Stop on the turn's abort signal; an abort that already happened stops at once. */
+function interruptOn(signal) {
+    return (stop) => {
+        if (signal.aborted) {
+            stop();
+            return () => { };
+        }
+        const handler = () => stop();
+        signal.addEventListener('abort', handler, { once: true });
+        return () => signal.removeEventListener('abort', handler);
+    };
+}
+export async function sessionTeamDeps(o) {
+    if (!o.headless && !o.signal)
+        throw new Error('A live journey step needs the turn abort signal, so Ctrl-C can stop a check.');
+    const said = [];
+    const confirm = journeyConfirm(o.headless, o.confirm);
+    let identity = o.identity;
+    if (!identity) {
+        const { getAuthorIdentity } = await import('../agent/loop.js');
+        // Read at each call, so it follows a join made during the journey: once this
+        // laptop records into a project, the name given for that project is the seat name.
+        identity = () => ({ name: activeProject()?.name ?? getAuthorIdentity().name });
+    }
+    const adt = o.adt;
+    const noSap = !!o.noSap || !adt;
+    const deps = {
+        print: (line) => said.push(line),
+        identity,
+        noSap,
+        // The session is connected to one system; that is the one used.
+        connect: noSap ? undefined : async () => ({
+            sql: (q, max) => adt.sqlQuery(q, max),
+            ...(o.sapAlias && o.sapAlias !== 'none' ? { system: { sid: o.sapAlias } } : {}),
+            atc: { runSet: (refs, variant, opts) => adt.atcRunSet(refs, variant, opts) },
+        }),
+        ask: askWith(confirm),
+        ...(o.signal ? { onInterrupt: interruptOn(o.signal) } : {}),
+        ...(o.now ? { now: o.now } : {}),
+        ...(o.rand ? { rand: o.rand } : {}),
+        ...(o.machine ? { machine: o.machine } : {}),
+    };
+    return { deps, said, confirm };
+}

package/dist/journey/trigger.js

@@ -0,0 +1,153 @@
+/**
+ * Guided clean-core journey, Task 3 — the sentences that start or resume a
+ * journey, detected in the CLI before the classifier (no proxy change).
+ *
+ * The rule, one sentence at a time:
+ *   - never a question: no sentence that ends in "?" or opens with a question
+ *     word (what, how, is, can, explain, tell, …);
+ *   - it opens with a start/check verb on clean core ("start clean core on …",
+ *     "let's begin a clean-core run on …"), or — with no verb on clean core
+ *     itself — it is ONLY names: "clean core for ZFI_AR and ZFI_GL",
+ *     "check ZFI_AR for clean core (and keep track of it)", a polite ending
+ *     allowed. "clean core for ZFI_AR is overdue" is a statement, not a start;
+ *   - it names at least one package, by code: ZFI_AR, zfi_ar, /NS/NAME.
+ *     A word like "your" is not a package: a name needs an underscore, a
+ *     digit, a namespace, or capitals as typed.
+ * Or the explicit form "/abap-clean-core start <PKG…>".
+ * A pattern (*, %, ?) in such a sentence is refused in one line; no journey.
+ *
+ * Resume, in a folder that holds a project with no plan step pending: any of
+ * "carry on" / "continue" / "continue clean core" picks up a journey this
+ * session paused; "continue clean core" also resumes after a clean turn with
+ * no answer pending; bare "carry on" / "continue" only as the session's first
+ * words. Otherwise "continue" keeps its old meaning.
+ */
+import { folderKind } from './clean-core.js';
+import { isJourneyPaused, isJourneyPausedJustNow, userTurnCount } from './flow.js';
+/** The runner's own words for a pattern (run.ts START). */
+export const PATTERN_LINE = 'Name each package in full, for example ZFI_AR — not a pattern.';
+const CC = String.raw `clean[\s-]?core`;
+const CLEAN_CORE = new RegExp(CC, 'i');
+/** Words in front of the verb that do not change what is asked. */
+const FILLER = new RegExp(String.raw `^(?:(?:let'?s|let us|please|now|ok(?:ay)?|so|then|and|right|go ahead and|time to|(?:i|we)(?:'d| would)? (?:like|want) to|(?:i|we) need to)[,]?\s+)+`, 'i');
+const QUESTION = /^(?:what|why|how|is|are|was|were|can|could|would|should|does|did|will|explain|tell|describe|which|when|where|who|whether|show)\b/i;
+/**
+ * Package names joined by "and", "," or "&" — nothing else. A name may hold
+ * *, % or ? here only so a pattern is caught and refused in its own words.
+ */
+const NAME = String.raw `(?:\/[A-Za-z0-9_]{1,10}\/[A-Za-z0-9_*%?]{1,30}|[ZzYy][A-Za-z0-9_*%?]{0,29})`;
+const NAMES = String.raw `${NAME}(?:(?:\s*,\s*|\s*&\s*|\s+and\s+|\s+)${NAME})*`;
+/** What may follow the names: a polite ending, never more sentence. */
+const TAIL = String.raw `(?:[\s,]+(?:please|now|today|for me|thanks|thank you))*`;
+/** After "check <names> for clean core": "and keep track of it" and the like. */
+const TRACK = String.raw `(?:\s+and\s+(?:keep\s+(?:a\s+)?track|track)(?:\s+of)?(?:\s+(?:it|them))?)?`;
+/** A verb on clean core opens the sentence: the names can follow in any words. */
+const VERB_OPENINGS = [
+    new RegExp(String.raw `^(?:start|begin|kick off|launch|set up|run)\s+(?:(?:a|the|our|my|up|with|on)\s+){0,2}${CC}\b`, 'i'),
+    new RegExp(String.raw `^check\s+(?:the\s+)?${CC}\b`, 'i'),
+];
+/**
+ * No verb on clean core itself: the sentence must hold only names (and a
+ * polite ending) — a statement ("clean core for ZFI_AR is overdue") never
+ * starts a paid step. Group 1 is the names slot; every word in it must look
+ * like a package as typed ("yes", "yet", "you" do not).
+ */
+const NAMES_OPENINGS = [
+    new RegExp(String.raw `^check\s+(${NAMES})\s+for\s+${CC}${TRACK}${TAIL}$`, 'i'),
+    new RegExp(String.raw `^${CC}\s+(?:for|on|with|of)\s+(${NAMES})${TAIL}$`, 'i'),
+];
+/** The package test, as typed: /NS/…, an underscore or a digit, or capitals. */
+const looksLikePackage = (typed) => typed.startsWith('/') || /[_\d]/.test(typed) || typed === typed.toUpperCase();
+/** True when the sentence opens a journey: a verb on clean core, or only package names. */
+function opensJourney(s) {
+    if (VERB_OPENINGS.some((re) => re.test(s)))
+        return true;
+    for (const re of NAMES_OPENINGS) {
+        const slot = re.exec(s)?.[1];
+        if (slot === undefined)
+            continue;
+        const words = slot.split(/\s*[,&]\s*|\s+/).filter((w) => w && w.toLowerCase() !== 'and');
+        if (words.length && words.every(looksLikePackage))
+            return true;
+    }
+    return false;
+}
+const EXPLICIT = /^\/(?:abap-)?clean-core\s+start(?:\s+([\s\S]*))?$/i;
+const PATTERN = /[*%]|[A-Za-z0-9_]\?[A-Za-z0-9_]/;
+/** A package as typed: /NS/NAME, or Z… / Y… (letters, digits, underscores). */
+const PACKAGE_TOKEN = /(?<![A-Za-z0-9_/])(\/[A-Za-z0-9_]{1,10}\/[A-Za-z0-9_]{1,30}|[ZzYy][A-Za-z0-9_]{1,29})(?![A-Za-z0-9_/])/g;
+const unique = (names) => [...new Set(names)];
+/** The sentences of a message: split after . ! ? and at line breaks. */
+function sentences(text) {
+    return text.replace(/[‘’]/g, "'").split(/(?<=[.!?])\s+|\r?\n+/).map((s) => s.trim()).filter(Boolean);
+}
+/** Package-looking names in a sentence, upper-cased, each once. */
+export function packagesIn(sentence) {
+    const out = [];
+    for (const m of sentence.matchAll(PACKAGE_TOKEN)) {
+        const typed = m[1];
+        if (looksLikePackage(typed))
+            out.push(typed.toUpperCase());
+    }
+    return unique(out);
+}
+/** A start sentence (or the explicit form), a refused pattern, or null. Pure. */
+export function parseJourneyStart(input) {
+    const text = input.trim();
+    const explicit = EXPLICIT.exec(text);
+    if (explicit) {
+        const rest = (explicit[1] ?? '').trim();
+        if (PATTERN.test(rest))
+            return { kind: 'refuse', line: PATTERN_LINE };
+        // As typed, upper-cased: the runner checks each one against the system.
+        const named = rest.split(/[\s,;]+/).filter((w) => w && !/^(and|or)$/i.test(w)).map((w) => w.toUpperCase());
+        return { kind: 'start', packages: unique(named) };
+    }
+    if (text.startsWith('/'))
+        return null;
+    for (const raw of sentences(text)) {
+        if (/\?\s*$/.test(raw) || QUESTION.test(raw))
+            continue;
+        const s = raw.replace(FILLER, '').replace(/[.!]+$/, '').trim();
+        if (QUESTION.test(s) || !opensJourney(s))
+            continue;
+        if (PATTERN.test(s))
+            return { kind: 'refuse', line: PATTERN_LINE };
+        const packages = packagesIn(s);
+        if (packages.length)
+            return { kind: 'start', packages };
+    }
+    return null;
+}
+/** "carry on", "continue", "continue (with) clean core". */
+export function isResumePhrase(input) {
+    const t = input.trim().toLowerCase().replace(/[.!]+$/, '').replace(/\s+/g, ' ');
+    return new RegExp(String.raw `^(?:carry on|continue)(?: (?:with )?(?:the )?${CC})?$`).test(t);
+}
+/**
+ * The journey this input asks for, or null (the input goes on as before).
+ * Resume needs a project in `cwd` and no plan step in flight. Then:
+ *   - right after a pause line, with no turn of the person's since, any of the
+ *     words resumes — even after an interrupted step (that is what paused it);
+ *   - otherwise nothing interrupted, no answer pending, and: a journey this
+ *     session paused, or the words name clean core, or it is the session's
+ *     first turn (text and image turns count; tool results do not).
+ */
+export function detectJourney(input, ctx) {
+    const start = parseJourneyStart(input);
+    if (start)
+        return start;
+    if (!isResumePhrase(input))
+        return null;
+    const s = ctx.session;
+    // Only whether a project file is there; the stage machine reads the rest.
+    if (s.plan_in_flight || folderKind(ctx.cwd, '').kind === 'none')
+        return null;
+    // Right after the pause line ("Say carry on"), with no turn of the person's
+    // since, the pause wins over an interrupted or waiting turn.
+    if (isJourneyPausedJustNow(ctx.session))
+        return { kind: 'resume' };
+    if (s.turnInterrupted || s.awaitingSkillAnswer)
+        return null;
+    return isJourneyPaused(ctx.session) || CLEAN_CORE.test(input) || userTurnCount(ctx.session) === 0 ? { kind: 'resume' } : null;
+}