@gaia-ai/addon-gaia-ui 0.7.0 → 0.9.0

package/dist/src/Entity/project/Screen/project-picker.d.ts

@@ -0,0 +1,80 @@
+import { BaseScreen, type ScreenContext } from '../../../Screen/screen.js';
+/**
+ * A project that claims the repo.
+ *
+ * `id` is what every node of its row is keyed on, which is what lets the
+ * picker's rows go through the shared table at all: `ListTable` reads row
+ * identity as `rowNodeId(noun, row.id)` for every list.
+ */
+export interface PickerCandidate {
+    id: string;
+    name: string;
+}
+export interface ProjectPickerInput {
+    readonly candidates: readonly PickerCandidate[];
+    readonly repo: string;
+}
+export declare const projectPickerInputContext: import("../../../Routing/context.js").ContextKey<ProjectPickerInput>;
+export declare class ProjectPickerScreen extends BaseScreen {
+    readonly frameId = "project-picker";
+    topTab(): {
+        readonly level: "root";
+        readonly tab: "projects";
+    };
+    static readonly route: {
+        id: string;
+        path: string;
+        parent: string;
+        fallback: {
+            routeId: string;
+        };
+        context: (_params: Readonly<Record<string, string>>, state: unknown, base: import("../../../Routing/context.js").ContextBag) => import("../../../Routing/context.js").ContextBag;
+    };
+    readonly id: string;
+    private candidates;
+    private repo;
+    selectedIndex: number;
+    enter(context: ScreenContext): void;
+    get rows(): readonly PickerCandidate[];
+    /**
+     * The question this screen asks, and the one place it is written.
+     *
+     * Both surfaces open with it — the tree as a keyed row above the table, the
+     * pipe as its first line — so composing it twice is how the two would come to
+     * disagree about the repo they name.
+     */
+    private headingText;
+    /** The candidate the cursor stands on, clamped: an out-of-range index must
+     *  move the marker, never lose it. */
+    private selected;
+    /**
+     * F5 — the pipe's own output, and it stays `string[]`.
+     *
+     * GAIA-345 D7/D8 — built from the SAME configuration the tree is, through
+     * `listTableRows` and `lineText`, plus the two heading lines and the trailing
+     * hint, which are the screen's and not rows of the list. The bytes are
+     * unchanged by construction rather than by a comparison somebody has to
+     * remember to make, and `tests/Entity/project/Screen/project-picker.test.ts`
+     * pins them line for line against the pre-conversion capture.
+     */
+    renderNonInteractive(): string[];
+    /**
+     * The picker's body: the question, a blank, then the list (GAIA-345 D8).
+     *
+     * The two heading rows are composed AROUND the table's node because they are
+     * not rows of it — they name no candidate, they are not selectable, and they
+     * carry no entry in `rowIds`. That is also what the old `selRow` offset of 2
+     * was compensating for before the kernel started finding the cursor by node.
+     *
+     * MOUNTED WHOLE — no window of its own, and the bound is named rather than
+     * assumed: a row is one `gaia_project` that claims the cwd's remote, which is
+     * the multisite topology GAIA-126/137 designs for. That is a handful of sites
+     * per repo, against `@opentui/core@0.5.1`'s ceiling of 16 382 renderables.
+     */
+    private surface;
+    present(_context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    handleInput(input: string, context: ScreenContext): boolean;
+    activate(index: number, context: ScreenContext): boolean;
+    select(index: number, context: ScreenContext): boolean;
+    reset(): void;
+}

package/dist/src/Entity/project/Screen/project-picker.js

@@ -0,0 +1,191 @@
+// GAIA-223 AC-8 (spec Decision 14) — the picker `gaia ui --here` shows when the
+// cwd's repo is claimed by MORE THAN ONE gaia project.
+//
+// One repo mapping to several projects is designed for, not an edge case:
+// GAIA-126/137 let `.gaia/` hold one conductor config per project, which is how
+// a Drupal multisite repo maps each site to its own GAIA project. Erroring on
+// N>1 would fail permanently, by design, in exactly the repos the feature is
+// most useful in — so the ambiguity is shown rather than resolved behind the
+// user's back.
+//
+// GAIA-345 D8 — `Component/project-picker/` is GONE and its two survivors live
+// here, in their only consumer: the candidate type and the one-column table the
+// two surfaces are both made of.
+import { lineText, } from '../../../Component/section-list/index.js';
+import { columnNode, textNode } from '../../../lib/vnode.js';
+import { defineContext } from '../../../Routing/context.js';
+import { BaseScreen, presentation, } from '../../../Screen/screen.js';
+import { listRowIds, listTableRows, listTableTree, } from '../../collection.js';
+/**
+ * The picker as a configuration (GAIA-345 D8) — one column, and NO HEADER.
+ *
+ * The header is declared away, and that is an operator decision taken against
+ * the direction that every other list gets one (D6): this is a question with
+ * choices rather than a table of records, and its single column has an empty
+ * label — so a header would paint an empty bold bar above the question.
+ *
+ * The `▸` stays in the cell's TEXT rather than becoming an attribute. It is
+ * what says "selected" to the pipe, which has no attributes to carry a
+ * highlight; the tree carries BOTH, the marker in the text and the inverse on
+ * the node, exactly as it did before this ticket.
+ *
+ * `Ctx` is the selected CANDIDATE rather than its index, because the column
+ * receives the row and not its position — the same reason row identity is the
+ * entity's uuid. The screen resolves it once per frame, clamped.
+ */
+const PICKER_TABLE = {
+    noun: 'project-picker',
+    header: false,
+    emptyMessage: 'No projects.',
+    columns: [
+        {
+            key: 'name',
+            label: '',
+            width: 0,
+            fields: ['name'],
+            get: (candidate, selected) => `${candidate === selected ? '▸' : ' '} ${candidate.name}`,
+        },
+    ],
+};
+export const projectPickerInputContext = defineContext('project-picker-input', 'input');
+/** Clamp a selection index into the candidate range (0 when there are none). */
+const clamp = (selected, length) => {
+    if (length <= 0)
+        return 0;
+    return Math.max(0, Math.min(Math.trunc(selected), length - 1));
+};
+export class ProjectPickerScreen extends BaseScreen {
+    frameId = 'project-picker';
+    topTab() {
+        return { level: 'root', tab: 'projects' };
+    }
+    static route = {
+        id: 'project.picker',
+        path: '/projects/pick',
+        parent: 'projects',
+        fallback: { routeId: 'project.dashboard' },
+        context: (_params, state, base) => state
+            ? base.set(projectPickerInputContext, state)
+            : base,
+    };
+    id = ProjectPickerScreen.route.id;
+    candidates = [];
+    repo = '';
+    selectedIndex = 0;
+    enter(context) {
+        const input = context.contexts?.has(projectPickerInputContext)
+            ? context.contexts.get(projectPickerInputContext)
+            : undefined;
+        if (input) {
+            this.candidates = [...input.candidates];
+            this.repo = input.repo;
+            this.selectedIndex = 0;
+        }
+        context.requestDraw();
+    }
+    get rows() {
+        return this.candidates;
+    }
+    /**
+     * The question this screen asks, and the one place it is written.
+     *
+     * Both surfaces open with it — the tree as a keyed row above the table, the
+     * pipe as its first line — so composing it twice is how the two would come to
+     * disagree about the repo they name.
+     */
+    headingText() {
+        return `Several gaia projects claim ${this.repo} — which one?`;
+    }
+    /** The candidate the cursor stands on, clamped: an out-of-range index must
+     *  move the marker, never lose it. */
+    selected() {
+        return this.candidates[clamp(this.selectedIndex, this.candidates.length)];
+    }
+    /**
+     * F5 — the pipe's own output, and it stays `string[]`.
+     *
+     * GAIA-345 D7/D8 — built from the SAME configuration the tree is, through
+     * `listTableRows` and `lineText`, plus the two heading lines and the trailing
+     * hint, which are the screen's and not rows of the list. The bytes are
+     * unchanged by construction rather than by a comparison somebody has to
+     * remember to make, and `tests/Entity/project/Screen/project-picker.test.ts`
+     * pins them line for line against the pre-conversion capture.
+     */
+    renderNonInteractive() {
+        return [
+            this.headingText(),
+            '',
+            ...listTableRows(PICKER_TABLE, this.candidates, this.selected()).map((line) => lineText(line)),
+            '',
+            'Run gaia ui project:<name> to choose directly.',
+        ];
+    }
+    /**
+     * The picker's body: the question, a blank, then the list (GAIA-345 D8).
+     *
+     * The two heading rows are composed AROUND the table's node because they are
+     * not rows of it — they name no candidate, they are not selectable, and they
+     * carry no entry in `rowIds`. That is also what the old `selRow` offset of 2
+     * was compensating for before the kernel started finding the cursor by node.
+     *
+     * MOUNTED WHOLE — no window of its own, and the bound is named rather than
+     * assumed: a row is one `gaia_project` that claims the cwd's remote, which is
+     * the multisite topology GAIA-126/137 designs for. That is a handful of sites
+     * per repo, against `@opentui/core@0.5.1`'s ceiling of 16 382 renderables.
+     */
+    surface() {
+        return columnNode('project-picker', textNode({
+            id: 'project-picker-heading',
+            content: this.headingText(),
+        }), textNode({ id: 'project-picker-heading-gap', content: '' }), listTableTree(PICKER_TABLE, this.candidates, this.selected(), {
+            selectedIndex: clamp(this.selectedIndex, this.candidates.length),
+        }));
+    }
+    present(_context) {
+        return presentation(this.surface(), {
+            selectable: this.candidates.length,
+            selectedIndex: this.selectedIndex,
+            // The node a click on each candidate lands on (GAIA-340 Task 11), read
+            // off the SAME configuration that keys the rows — which retires the
+            // hand-spelled `project-picker-candidate-<id>` the screen used to publish
+            // beside a row keyed the same way by a second expression (GAIA-345 D2).
+            rowIds: listRowIds(PICKER_TABLE, this.candidates),
+            title: 'Which project?',
+            meta: `${this.candidates.length} project(s) claim ${this.repo}  ·  Enter open · Esc dashboard`,
+            status: ' ↑↓ select · Enter open · Esc dashboard · q quit ',
+        });
+    }
+    handleInput(input, context) {
+        if (input === 'j' || input === 'down')
+            this.selectedIndex = Math.min(this.selectedIndex + 1, this.candidates.length - 1);
+        else if (input === 'k' || input === 'up')
+            this.selectedIndex = Math.max(this.selectedIndex - 1, 0);
+        else
+            return false;
+        context.requestDraw();
+        return true;
+    }
+    activate(index, context) {
+        const picked = this.candidates[index];
+        if (!picked || !context.navigate)
+            return false;
+        context.navigate('project.dashboard', {
+            projectId: picked.id,
+            projectName: picked.name,
+            projectSlug: picked.name,
+        });
+        return true;
+    }
+    select(index, context) {
+        if (index < 0 || index >= this.candidates.length)
+            return false;
+        this.selectedIndex = index;
+        context.requestDraw();
+        return true;
+    }
+    reset() {
+        this.candidates = [];
+        this.repo = '';
+        this.selectedIndex = 0;
+    }
+}

package/dist/src/Entity/project/Screen/projects-screen.d.ts

@@ -0,0 +1,52 @@
+import type { VNode } from '@opentui/core';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import { type ScreenContext } from '../../../Screen/screen.js';
+import { type ProjectRow } from '../Data/projects.js';
+/**
+ * GAIA-340 D1 — the ready page is a renderable TREE; `loading` and `error` are
+ * still three lines of text and stay rows (see `AsyncScreen`'s `Surface`).
+ *
+ * MOUNTED WHOLE, so the bound on its nodes is the data's own length against
+ * `@opentui/core@0.5.1`'s ceiling of 16 382 renderables. A project row is one
+ * box of 3 cells, and the rows are the user's own projects read from a single
+ * bounded `gaia_conductor` collection, grouped by project — three orders of
+ * magnitude of headroom on any control plane a person works with. This screen
+ * therefore windows nothing of its own, deliberately rather than by omission.
+ */
+export declare class ProjectsScreen extends AsyncScreen<ProjectRow[]> {
+    readonly frameId = "projects";
+    topTab(): {
+        readonly level: "root";
+        readonly tab: "projects";
+    };
+    reload(context: ScreenContext): void;
+    static readonly route: {
+        id: string;
+        path: string;
+        tab: {
+            id: string;
+            label: string;
+            scope: string;
+            order: number;
+        };
+    };
+    readonly id: string;
+    private readonly cursor;
+    /** Kept as a settable PUBLIC member: the kernel reads it and
+     *  `tests/Screen/project-screens.test.ts` writes it (GAIA-294 D2). */
+    get selectedIndex(): number;
+    set selectedIndex(value: number);
+    saveState(): {
+        selectedIndex: number;
+    };
+    restoreState(token: unknown): void;
+    get rows(): readonly ProjectRow[];
+    protected load(context: ScreenContext): Promise<ProjectRow[]>;
+    protected renderLoading(): string[];
+    protected renderReady(rows: ProjectRow[]): VNode;
+    present(context: ScreenContext): import("../../../Screen/screen.js").ScreenPresentation;
+    activate(index: number, context: ScreenContext): boolean;
+    select(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+    reset(): void;
+}

package/dist/src/Entity/project/Screen/projects-screen.js

@@ -0,0 +1,122 @@
+import { ListCursor } from '../../../lib/cursor.js';
+import { AsyncScreen } from '../../../Screen/async-screen.js';
+import { presentation } from '../../../Screen/screen.js';
+import { listRowIds, listTableTree } from '../../collection.js';
+import { loadProjectRows, PROJECT_TABLE, } from '../Data/projects.js';
+/**
+ * GAIA-340 D1 — the ready page is a renderable TREE; `loading` and `error` are
+ * still three lines of text and stay rows (see `AsyncScreen`'s `Surface`).
+ *
+ * MOUNTED WHOLE, so the bound on its nodes is the data's own length against
+ * `@opentui/core@0.5.1`'s ceiling of 16 382 renderables. A project row is one
+ * box of 3 cells, and the rows are the user's own projects read from a single
+ * bounded `gaia_conductor` collection, grouped by project — three orders of
+ * magnitude of headroom on any control plane a person works with. This screen
+ * therefore windows nothing of its own, deliberately rather than by omission.
+ */
+export class ProjectsScreen extends AsyncScreen {
+    frameId = 'projects';
+    topTab() {
+        return { level: 'root', tab: 'projects' };
+    }
+    reload(context) {
+        this.retry(context);
+    }
+    static route = {
+        id: 'projects',
+        path: '/projects',
+        tab: { id: 'projects', label: 'Projects', scope: 'root', order: 20 },
+    };
+    id = ProjectsScreen.route.id;
+    cursor = new ListCursor();
+    /** Kept as a settable PUBLIC member: the kernel reads it and
+     *  `tests/Screen/project-screens.test.ts` writes it (GAIA-294 D2). */
+    get selectedIndex() {
+        return this.cursor.index;
+    }
+    set selectedIndex(value) {
+        this.cursor.index = value;
+    }
+    saveState() {
+        return { selectedIndex: this.selectedIndex };
+    }
+    restoreState(token) {
+        if (token &&
+            typeof token === 'object' &&
+            typeof token.selectedIndex === 'number') {
+            this.selectedIndex = token.selectedIndex;
+        }
+    }
+    get rows() {
+        return this.readyValue ?? [];
+    }
+    load(context) {
+        if (!context.services)
+            throw new Error('Projects requires services');
+        return loadProjectRows({
+            client: context.services.client,
+            nowSeconds: context.nowSeconds ?? (() => Math.floor(Date.now() / 1000)),
+        });
+    }
+    renderLoading() {
+        return ['Loading projects…'];
+    }
+    renderReady(rows) {
+        // GAIA-345 AC 1 — the one table, configured. There is no `project-list`
+        // component any more: the columns, the noun and the empty message are
+        // `PROJECT_TABLE`, declared beside the row mapper that produces the rows.
+        return listTableTree(PROJECT_TABLE, rows, undefined, {
+            selectedIndex: this.selectedIndex,
+        });
+    }
+    present(context) {
+        const rows = this.rows;
+        return presentation(this.surface(context), {
+            selectable: rows.length,
+            selectedIndex: this.selectedIndex,
+            // The node a click on each row lands on (GAIA-340 Task 11), read off the
+            // SAME configuration that keys the rows — so the click target and the row
+            // node cannot be spelled two ways (GAIA-345 D2).
+            rowIds: listRowIds(PROJECT_TABLE, rows),
+            title: 'GAIA projects',
+            meta: `${rows.length} registered project(s)  ·  ${context.services?.baseUrl ?? ''}`,
+            status: ' ↑↓ select · Enter open · n new · Tab tabs · q quit ',
+        });
+    }
+    activate(index, context) {
+        const row = this.readyValue?.[index];
+        if (!row || !context.navigate)
+            return false;
+        context.navigate('project.dashboard', {
+            projectId: row.id,
+            projectName: row.projectName,
+            projectSlug: row.projectSlug,
+        });
+        return true;
+    }
+    select(index, context) {
+        if (index < 0 || index >= this.rows.length)
+            return false;
+        this.selectedIndex = index;
+        context.requestDraw();
+        return true;
+    }
+    handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
+        const rows = this.readyValue;
+        if (!rows)
+            return false;
+        if (this.cursor.handle(input, rows.length)) {
+            context.requestDraw();
+            return true;
+        }
+        if (input === 'enter')
+            return this.activate(this.selectedIndex, context);
+        return false;
+    }
+    reset() {
+        this.cursor.reset();
+        super.reset();
+    }
+}

package/dist/src/Entity/run/Component/run-detail/index.d.ts

@@ -1,17 +1,33 @@
-import type { Section } from '../../../../Component/section-list/index.js';
+import type { VNode } from '@opentui/core';
 import type { JsonApiResource, TicketDetailDocument } from '../../../../types.js';
 /** The sideloaded `gaia_run` with this id, or undefined. */
 export declare function runResource(document: TicketDetailDocument, runId: string | null | undefined): JsonApiResource | undefined;
 /** `#<id> · <ticket> · <state>` — the run screen's header-box title row. */
 export declare function runDetailTitle(document: TicketDetailDocument, runId: string | null | undefined): string;
 /**
- * The run's sections, in the order the screen draws them. An unresolvable run
- * yields ONE section saying so, rather than an empty screen that looks like a
- * failed render.
+ * The run block as the renderable tree the screen hands over (GAIA-340 D1).
+ *
+ * The FIRST screen on this side of the boundary, and the shape every other one
+ * follows: one node per row, each with an id that says what the row is, and the
+ * styling as props on the node rather than as indices into a surface the kernel
+ * has to interpret. The root is the component's own `run-detail`;
+ * `presentation()` puts the kernel's body-window root over it, because the id of
+ * that slot is the kernel's to know and a component may not import it.
  */
-export declare function runDetailSections(document: TicketDetailDocument, runId: string | null | undefined): Section[];
-/** The run block flattened — the screen's body, and the piped render (D7). */
-export declare function runDetailLines(document: TicketDetailDocument, runId: string | null | undefined): {
-    lines: string[];
-    boldRows: Set<number>;
-};
+export declare function runDetailTree(document: TicketDetailDocument, runId: string | null | undefined): VNode;
+/**
+ * The run block as PLAIN TEXT — the pipe's own output (spec F5).
+ *
+ * The operator's ruling after plan Task 10: a run is handled exactly like every
+ * other entity. `ticket.detail`, the dashboard and the project picker each print
+ * a deliberately different text into a pipe rather than a rendering of their
+ * surface; the run detail was the only entity detail that did not, which is the
+ * only reason its rows went through the tree→text path at all. That path renders
+ * a CELL GRID of a fixed width, and a pipe has no width: measured on run #4928,
+ * 420 transcript rows were clipped at 80 columns and 97.7 % of a 1.34 MB
+ * captured transcript never reached stdout.
+ *
+ * Nothing here measures a string (R5): a pipe's text is unpadded by definition,
+ * so this is the same rows the tree carries and no column arithmetic at all.
+ */
+export declare function runDetailRows(document: TicketDetailDocument, runId: string | null | undefined): string[];