@cspeach/cli 1.1.30 → 1.1.31

package/dist/journey/clean-core.js

@@ -0,0 +1,213 @@
+/**
+ * Guided clean-core journey, slice 1 (design .superpowers/sdd/guided-journey-design.md §2).
+ *
+ * The stage is derived from the folder every time it is needed — never stored.
+ * `stageOf` is pure: it reads only the facts handed to it. `readJourneyFacts`
+ * gathers those facts from the folder and the register, read only, and never
+ * throws: a folder halfway through a sync reads as UNREADABLE.
+ *
+ *   UNREADABLE the folder's project or its object list cannot be read now
+ *   INVENTORY  no discovery in the folder
+ *   START      no project in the folder
+ *   JOIN       a project in the folder this laptop does not record into
+ *   DECIDE     my objects with findings (or not measured) and no decision
+ *   FIX        my objects decided "fix" with no claim yet, then fixes that failed the check
+ *   PROVE      my objects whose fix is claimed and not measured since
+ *   REPORT     a record newer than the status page in reports/
+ *   DONE
+ *
+ * "Rebuild beside the core" is not an /abap-refactor job: those objects never
+ * hold the journey, and `toRedesign` lists them so a stage can say so.
+ *
+ * `skip` is the session's own memory (rows skipped, fixes put off): it never
+ * reaches the folder, so a new session asks again.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { DISCOVERY_DIR, TEAM_FILE, activeProject, readBaseline, readEstate, readProjectFile } from '../register/store.js';
+import { registerFor } from '../register/picture.js';
+import { reportFileNames } from '../register/workbooks.js';
+import { samePath } from '../commands/team-discover.js';
+export const STEPS = 6;
+/** "Step n of 6". Joining a project is part of step 2; UNREADABLE and DONE have no step. */
+const STAGE_STEP = {
+    INVENTORY: 1, START: 2, JOIN: 2, DECIDE: 3, FIX: 4, PROVE: 5, REPORT: 6,
+};
+export const stepOf = (stage) => STAGE_STEP[stage];
+/** States that need nothing more from the person. */
+const SETTLED = new Set(['clean', 'verified', 'retired']);
+/** A fix was claimed and a later check still found it (or found more). */
+const FAILED_CHECK = new Set(['did-not-hold', 'regressed']);
+const same = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+const byName = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+const size = (o) => (o.openFindings === null ? Number.MAX_SAFE_INTEGER : o.openFindings);
+const smallestFirst = (a, b) => size(a) - size(b) || byName(a, b);
+/** My objects: in a lane I own, in scope, not retired. */
+export function myObjects(register, me) {
+    const lanes = new Set(register.lanes.filter((l) => same(l.owner, me)).map((l) => l.id));
+    return register.objects.filter((o) => o.lane !== null && lanes.has(o.lane) && o.inScope && o.state !== 'retired');
+}
+/** My objects that still need a decision, in register order. */
+export function toDecide(register, me, skip = {}) {
+    return myObjects(register, me).filter((o) => !o.decision && !SETTLED.has(o.state) && !skip.decide?.has(o.key));
+}
+/** A triage is shown at most this many objects at a time (design §2: pages of 40). */
+export const PAGE_SIZE = 40;
+/**
+ * The next page to decide: the first objects left to decide in the area of
+ * the first one (the triage is queued for that one area), in register order,
+ * at most PAGE_SIZE.
+ */
+export function decidePage(register, me, skip = {}) {
+    const left = toDecide(register, me, skip);
+    const lane = left[0]?.lane;
+    return left.filter((o) => o.lane === lane).slice(0, PAGE_SIZE);
+}
+/**
+ * My objects decided "fix" that need a fix: first the ones nobody has claimed
+ * yet, then the ones whose claimed fix failed the check (did not hold, or
+ * regressed). Each group smallest first (fewest open findings, never measured last).
+ */
+export function toFix(register, me, skip = {}) {
+    const mine = myObjects(register, me).filter((o) => o.decision?.classification === 'fix' && !SETTLED.has(o.state) && !skip.fix?.has(o.key));
+    // A failed fix already claimed again waits for its check (toProve), not for another fix.
+    const retry = mine.filter((o) => FAILED_CHECK.has(o.state) && !claimedSinceCheck(o));
+    const fresh = mine.filter((o) => !FAILED_CHECK.has(o.state) && !o.fixes.some((f) => f.status === 'fixed'));
+    return [...fresh.sort(smallestFirst), ...retry.sort(smallestFirst)];
+}
+/**
+ * A `fixed` claim newer than the object's own last measurement. The register
+ * keeps a failed fix at did-not-hold / regressed until the NEXT check, even
+ * after a new claim; the journey reads the new claim as waiting for that check.
+ */
+export function claimedSinceCheck(o) {
+    const checked = o.lastMeasuredAt ? Date.parse(o.lastMeasuredAt) : NaN;
+    return o.fixes.some((f) => f.status === 'fixed' && (!Number.isFinite(checked) || Date.parse(f.at) > checked));
+}
+/** True when this object is in `toFix` because its fix failed the check. */
+export const fixFailedCheck = (o) => FAILED_CHECK.has(o.state);
+/** My objects planned for a rebuild beside the core — handled separately, never in the fix loop. */
+export function toRedesign(register, me) {
+    return myObjects(register, me).filter((o) => o.decision?.classification === 'redesign' && !SETTLED.has(o.state)).sort(byName);
+}
+/** My objects whose fix is claimed and not measured since — a failed fix claimed again included. */
+export function toProve(register, me) {
+    return myObjects(register, me).filter((o) => o.state === 'claimed' || (FAILED_CHECK.has(o.state) && claimedSinceCheck(o)));
+}
+/** The newest thing the register knows of, in ms; null when nothing is recorded. */
+export function newestRecordAt(register) {
+    let newest = null;
+    const take = (iso) => {
+        const t = iso ? Date.parse(iso) : NaN;
+        if (Number.isFinite(t) && (newest === null || t > newest))
+            newest = t;
+    };
+    take(register.lastMeasuredAt);
+    for (const o of register.objects)
+        take(o.lastRecordAt);
+    return newest;
+}
+/** Why the stage is UNREADABLE, as a reason kind; undefined when it is not. */
+export function unreadableReason(f) {
+    if (f.folder.kind === 'unreadable')
+        return f.folder.reason;
+    // Joined, yet no register was handed in: whatever stopped it is not one of the named cases.
+    if (f.folder.kind === 'joined' && !f.register)
+        return 'other';
+    return undefined;
+}
+export function stageOf(f) {
+    if (f.folder.kind === 'unreadable')
+        return 'UNREADABLE';
+    if (!f.hasDiscovery)
+        return 'INVENTORY';
+    if (f.folder.kind === 'none')
+        return 'START';
+    if (f.folder.kind !== 'joined')
+        return 'JOIN';
+    const r = f.register;
+    if (!r)
+        return 'UNREADABLE'; // unreadableReason(f) === 'other'
+    const skip = f.skip ?? {};
+    if (toDecide(r, f.me, skip).length)
+        return 'DECIDE';
+    if (toFix(r, f.me, skip).length)
+        return 'FIX';
+    if (!skip.prove && toProve(r, f.me).length)
+        return 'PROVE';
+    if (!skip.report) {
+        const newest = newestRecordAt(r);
+        if (f.reportsAt === null || (newest !== null && newest > f.reportsAt))
+            return 'REPORT';
+    }
+    return 'DONE';
+}
+/** Where the folder's project stands for this laptop. Never throws. */
+export function folderKind(cwd, me) {
+    if (!fs.existsSync(path.join(cwd, TEAM_FILE)))
+        return { kind: 'none' };
+    let project;
+    try {
+        project = readProjectFile(cwd);
+    }
+    catch {
+        return { kind: 'unreadable', reason: 'project-file' };
+    }
+    const who = { lead: project.lead.name, name: project.name };
+    let joined;
+    try {
+        joined = activeProject();
+    }
+    catch {
+        joined = null;
+    }
+    if (joined && joined.projectId === project.projectId && samePath(joined.projectDir, cwd))
+        return { kind: 'joined', ...who };
+    return same(project.lead.name, me) ? { kind: 'mine-not-joined', ...who } : { kind: 'someone-else', ...who };
+}
+/** mtime of the status page the report step writes, or null. */
+export function reportsAt(cwd, projectName) {
+    try {
+        return fs.statSync(path.join(cwd, 'reports', reportFileNames(projectName).html)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The facts for `stageOf`, read from the folder. The register is built only
+ * when this laptop records into the folder's project. Anything that cannot be
+ * read — a project file or object list halfway through a sync, a checksum that
+ * no longer matches — comes back as `folder.kind === 'unreadable'`, never as
+ * a thrown error.
+ */
+export function readJourneyFacts(cwd, me, skip) {
+    let hasDiscovery = false;
+    try {
+        hasDiscovery = fs.existsSync(path.join(cwd, DISCOVERY_DIR)) && readEstate(cwd) !== null;
+    }
+    catch {
+        hasDiscovery = false;
+    }
+    const folder = folderKind(cwd, me);
+    const facts = { hasDiscovery, folder, me, reportsAt: null, ...(skip ? { skip } : {}) };
+    if (folder.kind !== 'joined')
+        return facts;
+    try {
+        // The object list first, on its own: its failures (missing, garbled,
+        // checksum) are the everyday mid-sync case and get their own word.
+        readBaseline(cwd);
+    }
+    catch {
+        return { ...facts, folder: { kind: 'unreadable', reason: 'object-list' } };
+    }
+    try {
+        const joined = activeProject();
+        facts.register = registerFor(joined.projectDir, joined.outboxDir).register;
+        facts.reportsAt = reportsAt(cwd, folder.name);
+    }
+    catch {
+        return { ...facts, folder: { kind: 'unreadable', reason: 'other' } };
+    }
+    return facts;
+}

package/dist/journey/flow.js

@@ -0,0 +1,166 @@
+/**
+ * Guided clean-core journey, Task 3 — the session's journey, keyed on
+ * `ctx.session` (a WeakMap, like lane/app-flow.ts): nothing is written to the
+ * folder and nothing outlives the session. The stage itself is never kept —
+ * it is derived from the folder every time (clean-core.ts).
+ *
+ * Kept here: the packages the opening sentence named, the model step the
+ * journey queued (its exact command, the skill it runs as, and what it was
+ * meant to move), the page of objects the triage is shown (Task 4: at most
+ * 40 keys, read by team_findings), and the session skips ("Later", "Not now",
+ * a row skipped).
+ *
+ * While a journey is active the guarded-run override is on (its own share,
+ * plan-gate.ts setJourneyRunActive), so auto_approve never applies — the
+ * queued refactor included. It goes off when the journey ends or pauses; a
+ * plan turn's own guarded flag is never touched.
+ */
+import { setJourneyRunActive } from '../commands/plan-gate.js';
+import { shown } from '../register/atc-file.js';
+const flows = new WeakMap();
+/**
+ * Sessions whose journey paused (a stray turn, a put-away card, Ctrl-C), with
+ * the session's user-turn count at the pause: "carry on" right after the pause
+ * line wins over an interrupted or waiting turn; once another turn ran, it
+ * does not.
+ */
+const paused = new WeakMap();
+/** The person's turns in a session: user messages of text or images, never a tool result. */
+export function userTurnCount(session) {
+    const messages = session.messages ?? [];
+    return messages.filter((m) => m.role === 'user' && (typeof m.content === 'string'
+        || (Array.isArray(m.content) && m.content.some((b) => b?.type !== 'tool_result')))).length;
+}
+/** Skips survive a pause, so "carry on" does not ask again what was put off. */
+const skips = new WeakMap();
+/** Start (or restart) the journey for this session. */
+export function startJourneyFlow(session, packages = []) {
+    flows.set(session, { packages: [...packages] });
+    paused.delete(session);
+    setJourneyRunActive(true);
+}
+export function getJourneyFlow(session) {
+    const f = flows.get(session);
+    return f ? Object.freeze({
+        packages: [...f.packages],
+        ...(f.queued ? { queued: Object.freeze({ ...f.queued }) } : {}),
+        ...(f.page ? { page: [...f.page] } : {}),
+        ...(f.pages ? { pages: f.pages } : {}),
+    }) : undefined;
+}
+/** The page of objects the next triage is shown; one more page handed out. */
+export function setJourneyPage(session, keys) {
+    const f = flows.get(session);
+    if (!f)
+        return;
+    f.page = [...keys];
+    f.pages = (f.pages ?? 0) + 1;
+}
+/**
+ * The page the queued triage may see (team_findings shows only these), or
+ * undefined when no journey triage is queued: then the tool is as it always was.
+ */
+export function journeyPage(session) {
+    const f = session ? flows.get(session) : undefined;
+    return f?.queued?.stage === 'DECIDE' && f.page ? [...f.page] : undefined;
+}
+export const isJourneyActive = (session) => !!session && flows.has(session);
+/** True when `cmd` is the model step this session's journey queued (no echo for it). */
+export function isJourneyHop(session, cmd) {
+    return !!session && flows.get(session)?.queued?.command === cmd;
+}
+/**
+ * The one plain line a journey hop shows in place of the "You ›" echo — the
+ * person did not type the queued command, so it is never shown as theirs.
+ * Null when `cmd` is not this session's queued journey step: the echo stays.
+ */
+export function journeyHopLine(session, cmd) {
+    if (!isJourneyHop(session, cmd))
+        return null;
+    const f = flows.get(session);
+    const q = f.queued;
+    if (q.stage === 'DECIDE') {
+        const n = f.page ? f.page.length : q.left ?? 0;
+        return n > 0 ? `CSPeach is looking at your ${n} object${n === 1 ? '' : 's'}…` : 'CSPeach is looking at your objects…';
+    }
+    const name = q.key ? shown(q.key.slice(q.key.indexOf('|') + 1)).trim() : '';
+    return name ? `CSPeach is preparing the fix for ${name}…` : 'CSPeach is preparing the fix…';
+}
+export function setJourneyQueued(session, step) {
+    const f = flows.get(session);
+    if (!f)
+        return;
+    if (step)
+        f.queued = { ...step };
+    else
+        delete f.queued;
+}
+/** End the journey: the flow goes, the guarded run ends; skips stay for the session. */
+export function clearJourneyFlow(session) {
+    paused.delete(session);
+    if (!flows.has(session))
+        return;
+    flows.delete(session);
+    setJourneyRunActive(false);
+}
+/**
+ * Pause the journey: ended like clearJourneyFlow, and remembered so "carry on" picks it up.
+ * `offset`: user turns about to be counted that still belong to the pause — the
+ * gate pauses before the stray message is pushed, so it passes 1.
+ */
+export function pauseJourneyFlow(session, offset = 0) {
+    clearJourneyFlow(session);
+    paused.set(session, userTurnCount(session) + offset);
+}
+export const isJourneyPaused = (session) => !!session && paused.has(session);
+/** Paused, and no turn of the person's has run since the pause line. */
+export const isJourneyPausedJustNow = (session) => !!session && paused.has(session) && paused.get(session) === userTurnCount(session);
+/** The session skips as the stage machine reads them. */
+export function journeySkips(session) {
+    const s = skips.get(session);
+    if (!s)
+        return {};
+    const decide = new Set([...s.decide, ...(s.leftOut ?? [])]);
+    return {
+        ...(decide.size ? { decide } : {}),
+        ...(s.fix.size ? { fix: new Set(s.fix) } : {}),
+        ...(s.prove ? { prove: true } : {}),
+        ...(s.report ? { report: true } : {}),
+    };
+}
+export function addJourneySkips(session, add) {
+    if (!add)
+        return;
+    const s = skips.get(session) ?? { decide: new Set(), fix: new Set() };
+    for (const k of add.decide ?? [])
+        s.decide.add(k);
+    for (const k of add.fix ?? [])
+        s.fix.add(k);
+    if (add.prove)
+        s.prove = true;
+    if (add.report)
+        s.report = true;
+    skips.set(session, s);
+}
+/**
+ * Page objects the triage left out (Task 4, fix round 1): put off for now, and
+ * forgotten by "carry on" like the check and the report.
+ */
+export function addJourneyLeftOut(session, keys) {
+    if (!keys.length)
+        return;
+    const s = skips.get(session) ?? { decide: new Set(), fix: new Set() };
+    s.leftOut ??= new Set();
+    for (const k of keys)
+        s.leftOut.add(k);
+    skips.set(session, s);
+}
+/** "Carry on" asks the check, the report and the rows the triage left out again; fixes and rows skipped stay put off. */
+export function forgetNotNow(session) {
+    const s = skips.get(session);
+    if (!s)
+        return;
+    delete s.prove;
+    delete s.report;
+    delete s.leftOut;
+}