@north-light/crouter 0.3.233 → 0.3.234

package/dist/core/canvas/render.js

@@ -1,245 +0,0 @@
-// render.ts — the db-backed (sync, `openDb`) half of canvas rendering.
-//
-// Holds the SYNC renderers that read the local canvas.db directly
-// (renderTree/renderForest/dashboardRows/dashboardRowsAll/enrichRow(s)/loadPreview
-// /isNodeStreaming). The openDb-FREE `*FromSource` variants + every pure/disk
-// helper they share live in ./render-source.ts; this module imports those helpers
-// (one direction) and RE-EXPORTS the whole render-source module, so existing
-// importers of `render.js` keep resolving both the sync and the FromSource APIs
-// unchanged. A caller that must stay off openDb imports from ./render-source.js
-// directly instead.
-//
-// `subscriptionsOf(nodeId)` returns the nodes a node subscribes to (its reports /
-// children); walking it recursively walks DOWN the org chart.
-import { getNode, listNodes, subscriptionsOf, view } from './canvas.js';
-import { fullName } from './labels.js';
-import { countTickets, ticketCountsForNodes } from './attention.js';
-import { listFocuses } from './focuses.js';
-import { resolveNodeVisual, faultSummary } from './status-glyph.js';
-import { readNodeTelemetry, fmtCtx, hangingFor, isStreaming, dashboardRowFromNodeRow, readGoalText, readSessionParts, } from './render-source.js';
-// Re-export the openDb-free half so `render.js` importers keep resolving the
-// FromSource variants + shared types/helpers unchanged.
-export * from './render-source.js';
-// ---------------------------------------------------------------------------
-// Tree builder (sync, db-backed)
-// ---------------------------------------------------------------------------
-/** Build one line of the ASCII tree. */
-function nodeLine(nodeId, indent, connector) {
-    const node = getNode(nodeId);
-    if (node === null) {
-        // Node id is in the db but meta.json is gone — paranoid guard.
-        return `${indent}${connector}? <missing meta: ${nodeId}>`;
-    }
-    const hanging = hangingFor(node);
-    const glyph = resolveNodeVisual(node.status, { hanging }).glyph;
-    const tel = readNodeTelemetry(nodeId);
-    const ctx = fmtCtx(tel.tokens_in);
-    const asks = countTickets(nodeId);
-    const askSuffix = asks > 0 ? ` ⚑${asks}` : '';
-    const faultSuffix = hanging !== null ? ` · ${faultSummary(hanging)}` : '';
-    return `${indent}${connector}${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}${faultSuffix}`;
-}
-/**
- * Recursively walk the subscription sub-DAG rooted at `nodeId`, appending
- * rendered lines to `out`. Cycle-safe via `visited`.
- */
-function walkTree(nodeId, indent, isLast, visited, out) {
-    // Guard: if we have already rendered this node in this traversal, emit a
-    // back-ref marker instead of recursing (prevents infinite loops in graphs
-    // with cycles introduced by manual edge manipulation).
-    if (visited.has(nodeId)) {
-        // The line for this node was already emitted by the caller; just return.
-        return;
-    }
-    visited.add(nodeId);
-    const connector = isLast ? '└─ ' : '├─ ';
-    out.push(nodeLine(nodeId, indent, connector));
-    const children = subscriptionsOf(nodeId);
-    const childIndent = indent + (isLast ? '   ' : '│  ');
-    for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        const childIsLast = i === children.length - 1;
-        if (visited.has(child.node_id)) {
-            // Cycle reference — show the back-edge without recursing.
-            const cycleConnector = childIsLast ? '└─ ' : '├─ ';
-            out.push(`${childIndent}${cycleConnector}↺ <cycle: ${child.node_id}>`);
-            continue;
-        }
-        walkTree(child.node_id, childIndent, childIsLast, visited, out);
-    }
-}
-// ---------------------------------------------------------------------------
-// Public API (sync)
-// ---------------------------------------------------------------------------
-/**
- * Render the subscription sub-DAG rooted at `rootId` as an ASCII tree.
- * The root is the first line (no connector prefix); children are indented.
- *
- * Each line: `<glyph> <name> [<kind>/<mode>] ctx <Nk>[ ⚑<asks>]`
- *
- * Returns a multi-line string (no trailing newline).
- */
-export function renderTree(rootId) {
-    const node = getNode(rootId);
-    if (node === null)
-        return `? <missing node: ${rootId}>`;
-    const tel = readNodeTelemetry(rootId);
-    const ctx = fmtCtx(tel.tokens_in);
-    const asks = countTickets(rootId);
-    const askSuffix = asks > 0 ? ` ⚑${asks}` : '';
-    const hanging = hangingFor(node);
-    const glyph = resolveNodeVisual(node.status, { hanging }).glyph;
-    const faultSuffix = hanging !== null ? ` · ${faultSummary(hanging)}` : '';
-    const out = [];
-    out.push(`${glyph} ${fullName(node)} [${node.kind}/${node.mode}] ctx ${ctx}${askSuffix}${faultSuffix}`);
-    // visited starts with root already rendered (walkTree doesn't re-emit root).
-    const visited = new Set([rootId]);
-    const children = subscriptionsOf(rootId);
-    for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        const isLast = i === children.length - 1;
-        walkTree(child.node_id, '', isLast, visited, out);
-    }
-    return out.join('\n');
-}
-/**
- * Render all canvas roots as a forest. A root is a node with no subscribers
- * (no one subscribes to it = it has no managers in the org chart).
- *
- * If there are no roots on the canvas, returns a placeholder string.
- */
-export function renderForest() {
-    const all = listNodes();
-    if (all.length === 0)
-        return '(canvas is empty)';
-    // A root has no subscribers (nobody is watching it). We discover this by
-    // looking for nodes whose node_id never appears as a "to" side of a
-    // subscribes_to edge — equivalently, nodes with parent === null are the
-    // authoritative roots per the spawn contract (spawn sets parent and records
-    // a spawned_by edge + subscribe). Fall back to parent===null because querying
-    // the full edge table would require opening the db here.
-    //
-    // Fine to use parent===null: roots are created by bare `crtr` / `node new --root`
-    // without a parent; non-roots always have a parent.
-    //
-    // Filter to LIVE roots: each `/new` parks a `done` root (option C relaunch)
-    // with parent===null, so an unfiltered forest would render every parked root
-    // as a sibling tree and clutter the dashboard. Showing only active|idle roots
-    // drops parked (`done`) roots and, as a bonus, stray `dead`/`canceled` roots.
-    // Parked roots stay reachable by id (inspect / revive / focus).
-    const roots = all.filter((n) => n.parent === null && (n.status === 'active' || n.status === 'idle'));
-    // No LIVE roots: render an empty/placeholder forest rather than resurrecting
-    // parked (`done`) / dead / canceled roots. The live-only filter is the intent;
-    // falling back to all-status roots would re-clutter the dashboard with the very
-    // parked trees the filter drops (e.g. a sole root `/quit`'d with no `/new`).
-    // Parked roots stay reachable by id (inspect / revive / focus).
-    if (roots.length === 0)
-        return '(no live roots)';
-    const parts = [];
-    for (const r of roots) {
-        parts.push(renderTree(r.node_id));
-    }
-    return parts.join('\n\n');
-}
-// ---------------------------------------------------------------------------
-// Structured row builder (sync, db-backed)
-// ---------------------------------------------------------------------------
-/** One row per node visible in the sub-DAG of `rootId` (including root). */
-export function dashboardRows(rootId) {
-    const ids = [rootId, ...view(rootId)];
-    return ids.flatMap((id) => {
-        const node = getNode(id);
-        if (node === null)
-            return [];
-        const tel = readNodeTelemetry(id);
-        return [{
-                node_id: id,
-                name: fullName(node),
-                handle: node.name,
-                description: node.description,
-                status: node.status,
-                kind: node.kind,
-                mode: node.mode,
-                ctx_tokens: tel.tokens_in ?? 0,
-                asks: countTickets(id),
-                cwd: node.cwd,
-                created: node.created,
-            }];
-    });
-}
-/**
- * CHEAP boot builder — one row per node across the entire canvas, with only the
- * fields that need no per-node meta/telemetry/session read. Two db queries total:
- * `listNodes()` + `listFocuses()` (the focus set replaces per-node getFocusByNode
- * calls). See {@link dashboardRowFromNodeRow} for the per-row projection, and
- * {@link enrichRow}/{@link enrichRows}/{@link loadPreview} for the lazy fields.
- */
-export function dashboardRowsAll() {
-    const focusedNodeIds = new Set(listFocuses().map((f) => f.node_id));
-    return listNodes().map((row) => dashboardRowFromNodeRow(row, focusedNodeIds, false));
-}
-// ---------------------------------------------------------------------------
-// Lazy enrichment API (sync, db-backed) — fold the expensive per-node reads into
-// rows on demand, for the VISIBLE viewport / top tiers only (never all up front).
-// Each function mutates the row in place and is idempotent via a guard flag.
-// ---------------------------------------------------------------------------
-/** Fold the cheap-boot row's deferred fields in for ONE row: the full label
- *  (meta.description → fullName), ctx tokens (telemetry.json), and ⚑ asks. One
- *  meta read + one telemetry read + one ticket scan. Idempotent (no-op once enriched).
- *  For a batch, prefer {@link enrichRows} — it scans each cwd's ticket inbox once. */
-export function enrichRow(row) {
-    if (row.enriched === true)
-        return row;
-    const meta = getNode(row.node_id);
-    if (meta !== null) {
-        row.name = fullName(meta);
-        row.handle = meta.name;
-        row.description = meta.description;
-    }
-    row.ctx_tokens = readNodeTelemetry(row.node_id).tokens_in ?? 0;
-    row.asks = countTickets(row.node_id);
-    row.enriched = true;
-    return row;
-}
-/** Batch {@link enrichRow}: enrich every not-yet-enriched row, scanning each
- *  distinct cwd's ticket inbox exactly ONCE (via `ticketCountsForNodes`) instead
- *  of per row. Use this for a whole viewport / the full forest; mutates each row in place. */
-export function enrichRows(rows) {
-    const todo = rows.filter((r) => r.enriched !== true);
-    if (todo.length === 0)
-        return;
-    const asks = ticketCountsForNodes(todo.map((r) => r.node_id));
-    for (const row of todo) {
-        const meta = getNode(row.node_id);
-        if (meta !== null) {
-            row.name = fullName(meta);
-            row.handle = meta.name;
-            row.description = meta.description;
-        }
-        row.ctx_tokens = readNodeTelemetry(row.node_id).tokens_in ?? 0;
-        row.asks = asks[row.node_id] ?? 0;
-        row.enriched = true;
-    }
-}
-/** Load the SELECTED row's preview text: the spawn `goal` (initial-prompt.md) plus
- *  the whole-conversation `prompts` and the `lastAssistant` reply — the latter two
- *  folded into ONE session-file read (see {@link readSessionParts}). Mutates the row
- *  in place; idempotent. Call only for the cursor row (and lazily/in-background to
- *  warm the prompt super-search corpus), never on the boot path. */
-export function loadPreview(row) {
-    if (row.previewLoaded === true)
-        return row;
-    row.goal = readGoalText(row.node_id);
-    const meta = getNode(row.node_id);
-    const { prompts, lastAssistant } = readSessionParts(meta?.pi_session_file);
-    row.prompts = prompts;
-    row.lastAssistant = lastAssistant;
-    row.previewLoaded = true;
-    return row;
-}
-/** {@link isStreaming} keyed by node id alone — hydrates the broker pid off the
- *  db row. The exported "is this node actively generating right now?" guard so a
- *  reap never nukes a node mid-first-turn before its output lands on disk. */
-export function isNodeStreaming(nodeId) {
-    return isStreaming(nodeId, getNode(nodeId)?.pi_pid ?? null);
-}