@north-light/crouter 0.3.236 → 0.3.238

package/dist/commands/sys/context/admin/model.js

@@ -0,0 +1,209 @@
+// The read model behind `crtr sys context admin`: the configuration snapshot
+// the page dials, the per-event delivery plans it resolves from, and the
+// vocabulary both the matrix and the dossier read from.
+import { resolve as resolvePath } from 'node:path';
+import { theme } from '../../../../core/tui/panel.js';
+import { realpathOrSelf } from '../../../../core/fs-utils.js';
+import { planDelivery, } from '../../../../core/substrate/plan.js';
+import { RUNGS, SURFACE_EVENTS, rungRank, } from '../../../../core/substrate/schema.js';
+import { scopeForCwd, profileNameFor } from '../../../../core/substrate/subject-fields.js';
+import { resolveMemoryDocForTarget } from '../../../../core/memory-resolver.js';
+export function subjectOf(snapshot) {
+    return {
+        kind: snapshot.kind,
+        mode: snapshot.mode,
+        lifecycle: snapshot.lifecycle,
+        hasManager: snapshot.hasManager,
+        cwd: snapshot.cwd,
+        scope: scopeForCwd(snapshot.cwd),
+        orchestration: { depth: snapshot.depth },
+        profile: profileNameFor(snapshot.profileId),
+    };
+}
+export function targetOf(snapshot) {
+    return { cwd: snapshot.cwd, profileId: snapshot.profileId, nodeId: snapshot.nodeId };
+}
+/** Which payload axis an event reads, so the rail offers exactly the one field
+ *  that can make the current event match anything. */
+export function payloadAxisFor(event) {
+    if (event === 'read')
+        return 'file';
+    if (event === 'memory-read')
+        return 'docName';
+    if (event === 'command' || event === 'pre-command')
+        return 'command';
+    return null;
+}
+/** Every plan for one snapshot, computed on demand.
+ *
+ *  Each event's corpus is its own — workspace-open sees project stores only,
+ *  boot orders node-local documents last, read pulls in the stores enclosing
+ *  the read file — so a shared corpus would report a delivery the runtime would
+ *  never make. The planner therefore loads per event, and this cache keeps the
+ *  page responsive by resolving the focused event first and warming the rest
+ *  one macrotask at a time. */
+export class PlanSet {
+    snapshot;
+    plans = new Map();
+    warming;
+    constructor(snapshot) {
+        this.snapshot = snapshot;
+    }
+    setSnapshot(snapshot) {
+        this.snapshot = snapshot;
+        this.invalidate();
+    }
+    /** Drop every plan — after a snapshot change, or after a mutation rewrote a
+     *  document the corpus was read from. */
+    invalidate() {
+        this.plans.clear();
+        if (this.warming !== undefined) {
+            clearTimeout(this.warming);
+            this.warming = undefined;
+        }
+    }
+    dispose() {
+        if (this.warming !== undefined)
+            clearTimeout(this.warming);
+        this.warming = undefined;
+    }
+    /** The plan for one event, computing it now. */
+    plan(event) {
+        const held = this.plans.get(event);
+        if (held !== undefined)
+            return held;
+        const computed = planDelivery(subjectOf(this.snapshot), targetOf(this.snapshot), event, this.payload(event));
+        this.plans.set(event, computed);
+        return computed;
+    }
+    /** The plan for one event only if it is already computed — what the matrix
+     *  reads, so an uncomputed column draws as pending instead of stalling the
+     *  frame on five extra corpus loads. */
+    peek(event) {
+        return this.plans.get(event);
+    }
+    /** Compute one pending event per macrotask, calling back after each so the
+     *  matrix fills in column by column. */
+    warm(onProgress) {
+        if (this.warming !== undefined)
+            return;
+        const pending = SURFACE_EVENTS.find((event) => !this.plans.has(event));
+        if (pending === undefined)
+            return;
+        this.warming = setTimeout(() => {
+            this.warming = undefined;
+            this.plan(pending);
+            onProgress();
+            this.warm(onProgress);
+        }, 0);
+    }
+    payload(event) {
+        if (event === 'read') {
+            // Against the DIALLED cwd, not this process's: the axes rail accepts a
+            // relative path and the page plans for the snapshot's directory.
+            return this.snapshot.file === ''
+                ? {}
+                : { absoluteFile: resolvePath(this.snapshot.cwd, this.snapshot.file) };
+        }
+        if (event === 'memory-read') {
+            if (this.snapshot.docName === '')
+                return {};
+            return {
+                resolvedCanonicalName: this.snapshot.docName,
+                resolvedDocPath: resolvedDocRealpath(this.snapshot.docName, targetOf(this.snapshot)),
+            };
+        }
+        if (event === 'command' || event === 'pre-command') {
+            return this.snapshot.command === '' ? {} : { command: this.snapshot.command };
+        }
+        return {};
+    }
+}
+/** The read document never delivers to itself, so a `memory-read` plan needs
+ *  the resolved document's physical path — the same exclusion the live read
+ *  path passes. A name that resolves to nothing excludes nothing. */
+function resolvedDocRealpath(name, target) {
+    try {
+        return realpathOrSelf(resolveMemoryDocForTarget(name, target).path);
+    }
+    catch {
+        return '';
+    }
+}
+export function cellStateOf(record) {
+    if (record === undefined)
+        return 'silent';
+    if (!record.docGate.pass)
+        return 'gated';
+    if (record.shadowedBy !== null)
+        return 'shadowed';
+    if (record.finalRung !== 'none') {
+        return rungRank(record.finalRung) < rungRank(record.authoredRung) ? 'capped' : 'delivers';
+    }
+    if (record.authoredRung !== 'none')
+        return 'capped';
+    if (record.entryGate !== null && !record.entryGate.pass)
+        return 'gated';
+    return 'silent';
+}
+const RUNG_GLYPH = { none: '·', name: '▁', preview: '▄', content: '█' };
+/** One matrix cell: the delivered rung as a filled bar, or the mark that says
+ *  why nothing is delivered. Colour separates a clean delivery from one the
+ *  profile cap trimmed, so a capped `content` never reads as an authored one. */
+export function cellGlyph(record, state) {
+    if (state === 'pending')
+        return theme.fg('dim', '…');
+    if (state === 'gated')
+        return theme.fg('warning', '×');
+    if (state === 'shadowed')
+        return theme.fg('muted', '∅');
+    if (record === undefined || state === 'silent')
+        return theme.fg('dim', RUNG_GLYPH.none);
+    const glyph = RUNG_GLYPH[record.finalRung];
+    if (state === 'capped')
+        return theme.fg('warning', record.finalRung === 'none' ? '⌐' : glyph);
+    return theme.fg('success', glyph);
+}
+/** The one-letter column heads over the matrix, in `SURFACE_EVENTS` order. */
+export const EVENT_INITIALS = {
+    boot: 'b',
+    'workspace-open': 'w',
+    read: 'r',
+    'memory-read': 'm',
+    command: 'c',
+    'pre-command': 'p',
+};
+export function nextRung(rung, delta) {
+    const at = (rungRank(rung) + delta + RUNGS.length) % RUNGS.length;
+    return RUNGS[at];
+}
+/** A parsed entry back in the shape `memory edit --surface` accepts. The parsed
+ *  form always carries `match` as a list and spells its frontmatter key
+ *  `matchFrontmatter`; `coerceSurface` wants a bare string for a single glob
+ *  and the hyphenated key, and rejects anything else. */
+export function surfaceEntryToFlag(entry) {
+    const match = entry.match === undefined || entry.match.length === 0
+        ? undefined
+        : entry.match.length === 1 ? entry.match[0] : entry.match;
+    return JSON.stringify({
+        on: entry.on,
+        ...(match === undefined ? {} : { match }),
+        ...(entry.matchFrontmatter === undefined ? {} : { 'match-frontmatter': entry.matchFrontmatter }),
+        ...(entry.gate === undefined ? {} : { gate: entry.gate }),
+        at: entry.at,
+    });
+}
+/** One authored entry as a single readable row. */
+export function describeSurfaceEntry(entry) {
+    const parts = [entry.on];
+    if (entry.match !== undefined && entry.match.length > 0)
+        parts.push(entry.match.join(' | '));
+    if (entry.matchFrontmatter !== undefined)
+        parts.push(`fm ${JSON.stringify(entry.matchFrontmatter)}`);
+    if (entry.gate !== undefined)
+        parts.push(`gate ${JSON.stringify(entry.gate)}`);
+    return `${parts.join('  ')} → ${entry.at}`;
+}
+export function plural(count, one, many) {
+    return `${count} ${count === 1 ? one : many}`;
+}

package/dist/commands/sys/context/admin/shell.d.ts

@@ -0,0 +1,82 @@
+import { type Component, type Focusable, type TUI } from '@earendil-works/pi-tui';
+import { type BindingId, type BindingResolution } from '../../../../core/keybindings/index.js';
+import { type CapChange } from './actions.js';
+import { type Snapshot } from './model.js';
+export interface AdminResult {
+    edited: string[];
+    capChanges: CapChange[];
+}
+export declare class ContextAdminShell implements Component, Focusable {
+    private readonly tui;
+    private readonly terminalRows;
+    private readonly bindings;
+    private readonly suspendForChild;
+    private snapshot;
+    private plans;
+    private zone;
+    private axisIndex;
+    private readonly docs;
+    private readonly detail;
+    private modal;
+    private notice;
+    private busy;
+    private readonly edited;
+    private readonly capChanges;
+    private _focused;
+    onCancel?: () => void;
+    onSubmit?: (result: AdminResult) => void;
+    constructor(seed: Snapshot, tui: TUI, terminalRows: () => number, bindings: BindingResolution<BindingId>, suspendForChild: () => () => void);
+    set focused(value: boolean);
+    get focused(): boolean;
+    /** Required by `Component`. Nothing is cached between frames: a plan can land
+     *  from a warm tick and an edit can land from an await, both between inputs. */
+    invalidate(): void;
+    dispose(): void;
+    /** Recompute the focused event's plan, refresh the panels from it, and let
+     *  the remaining events fill in behind it. */
+    private rebuild;
+    private syncDetail;
+    private setSnapshot;
+    private matches;
+    private label;
+    private isDown;
+    private isUp;
+    private isDescend;
+    private isAscend;
+    /** Tab steps the focused event from any zone — the one axis every panel is
+     *  drawn against, so it earns the page-level gesture. */
+    private cyclesEvent;
+    handleInput(data: string): void;
+    private handleAxes;
+    private handleDocs;
+    private handleDetail;
+    /** What the focused dossier row does when opened — the same write its letter
+     *  key starts, so a user who never learns the letters can still edit. */
+    private activate;
+    private get record();
+    private apply;
+    private cycleEntryRung;
+    private removeEntry;
+    /** Event, then match, then rung — the three fields a valid entry needs, asked
+     *  in the order the schema reads them. */
+    private composeEntry;
+    private editGate;
+    private flip;
+    private editRouting;
+    private editShortForm;
+    /** The one write that leaves the page: the terminal goes to $EDITOR and comes
+     *  back repainted, and the buffer that returns is saved through `memory edit`
+     *  like every other field here. */
+    private editBody;
+    private editMove;
+    /** The ceiling belongs to the profile project entry that governs the store,
+     *  not to the document, so this write is offered only when one exists. */
+    private editCap;
+    private openAxisField;
+    private close;
+    private handleModal;
+    private renderModal;
+    private footer;
+    render(width: number): string[];
+}
+export declare function runContextAdmin(seed: Snapshot): Promise<AdminResult | undefined>;