@bakers-build/addon-bakers-ui-artifacts 0.0.0-stage → 0.1.0-next.38

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 keytec GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @bakers-build/addon-bakers-ui-artifacts
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+bakers.build TUI: an Artifacts tab on ticket detail, reading assets-ai/<bakers.build-nnn>/.
+
+Part of the bakers.build CLI. Install the meta package `@bakers-build/bakers` to get the `bakers` CLI with all addons. Source: https://git.key-tec.de/bakers-build/bakers-build (bakers-cli/).

package/dist/src/panel.d.ts

@@ -0,0 +1,36 @@
+import { type ActionItem, AsyncScreen, type RouteMetadata, type ScreenAction, type ScreenContext, type TicketDetailDocument } from '@bakers-build/addon-bakers-ui/ui';
+export declare class ArtifactsTabScreen extends AsyncScreen<TicketDetailDocument> {
+    static readonly route: RouteMetadata;
+    readonly id = "ticket.artifacts";
+    readonly frameId = "ticket";
+    private selectedEntry;
+    private expanded;
+    private status;
+    private releaseStore;
+    protected load(context: ScreenContext): Promise<TicketDetailDocument>;
+    enter(context: ScreenContext): void;
+    leave(): void;
+    reload(context: ScreenContext): void;
+    protected renderLoading(): string[];
+    private sections;
+    private view;
+    protected renderReady(_document: TicketDetailDocument, context: ScreenContext): import("@opentui/core").VNode<any, import("@opentui/core").VChild[]>;
+    protected chrome(context: ScreenContext): {
+        selectable: number;
+        selectedIndex: number;
+        rowIds: string[];
+        cursorMode: "select" | "scroll";
+        header?: import("@opentui/core").VNode<any, import("@opentui/core").VChild[]>;
+        title: string;
+    };
+    protected actions(context: ScreenContext): readonly ActionItem[];
+    protected notice(): string | undefined;
+    select(index: number, context: ScreenContext): boolean;
+    activate(index: number, context: ScreenContext): boolean;
+    handleInput(input: string, context: ScreenContext): boolean;
+    commandForInput(input: string): "edit-assignment" | undefined;
+    actionForInput(input: string, context: ScreenContext): ScreenAction | undefined;
+    receiveResult(result: unknown, context: ScreenContext): void;
+    renderNonInteractive(context: ScreenContext): string[];
+    reset(): void;
+}

package/dist/src/panel.js

@@ -0,0 +1,201 @@
+import { AsyncScreen, actionItem, firstLineSummary, flattenSections, handleTicketCopy, plainLine, readTicket, saveTicket, tabViewTree, ticketCopyActions, ticketEditAction, ticketHeaderTree, ticketInputContext, ticketTitleOf, watchTicket, } from '@bakers-build/addon-bakers-ui/ui';
+import { artifactRoots, artifactSections } from './tree.js';
+/** How many lines of one artifact an expanded entry shows (spec D9). */
+const HEAD_LINES = 200;
+const attribute = (doc, name) => {
+    const value = doc?.data?.attributes?.[name];
+    return typeof value === 'string' ? value : '';
+};
+export class ArtifactsTabScreen extends AsyncScreen {
+    static route = {
+        id: 'ticket.artifacts',
+        path: '/tickets/:ticketId/artifacts',
+        parent: 'project.tickets',
+        tab: { id: 'artifacts', label: 'Artifacts', scope: 'ticket', weight: 50 },
+        fallback: { routeId: 'my.work' },
+        context: ticketInputContext,
+    };
+    id = 'ticket.artifacts';
+    frameId = 'ticket';
+    selectedEntry = 0;
+    expanded = new Set();
+    status = '';
+    releaseStore;
+    load(context) {
+        return Promise.resolve(readTicket(context));
+    }
+    enter(context) {
+        this.releaseStore?.();
+        super.enter(context);
+        if (this.state === 'ready')
+            this.replaceReady(readTicket(context, this.readyValue));
+        this.releaseStore = watchTicket(context, (document) => {
+            if (this.state === 'ready')
+                this.replaceReady(document);
+            context.requestDraw();
+        });
+    }
+    leave() {
+        this.releaseStore?.();
+        this.releaseStore = undefined;
+        super.leave();
+    }
+    reload(context) {
+        this.retry(context);
+    }
+    renderLoading() {
+        return ['Loading artifacts…'];
+    }
+    sections(context) {
+        const doc = this.readyValue;
+        const ctx = { cwd: context.options?.cwd };
+        const identifier = attribute(doc, 'identifier');
+        if (ctx.cwd === undefined || identifier === '') {
+            return [
+                {
+                    heading: 'Artifacts',
+                    lines: [
+                        'This cockpit has no checkout to read artifacts from.',
+                        'Artifacts are transient and local (BB-371 D1/D10).',
+                    ],
+                },
+            ];
+        }
+        const roots = artifactRoots(ctx.cwd, identifier, attribute(doc, 'branch_name'));
+        const sections = artifactSections(roots, { headLines: HEAD_LINES });
+        // The empty state NAMES BOTH PROBED PATHS. BB-371 D10 is a real hole —
+        // on another machine the worktree is gone — and naming the paths is what
+        // turns a blank tab into a diagnosis.
+        return sections.length > 0
+            ? sections
+            : [
+                {
+                    heading: 'Artifacts',
+                    lines: [
+                        'No artifacts in this checkout. Probed:',
+                        ...roots.map((root) => `  ${root}`),
+                        '',
+                        'Artifacts die with the worktree (BB-371 D1/D10).',
+                    ],
+                },
+            ];
+    }
+    view(context) {
+        return tabViewTree(this.readyValue, -1, {
+            panelSections: this.sections(context),
+            expanded: this.expanded,
+            selectedIndex: this.selectedEntry,
+        });
+    }
+    renderReady(_document, context) {
+        return this.view(context).body;
+    }
+    chrome(context) {
+        const document = this.readyValue;
+        const { identifier, title } = ticketTitleOf(document ?? {});
+        const view = this.view(context);
+        return {
+            title: document?.data
+                ? `${identifier} · ${title}`
+                : (context.params?.ticketId ?? 'ticket'),
+            ...(document?.data
+                ? { header: ticketHeaderTree(document, identifier, title, []) }
+                : {}),
+            selectable: view.selectable,
+            selectedIndex: this.selectedEntry,
+            rowIds: view.rowIds,
+            cursorMode: view.selectable > 1 ? 'select' : 'scroll',
+        };
+    }
+    actions(context) {
+        const count = this.view(context).selectable;
+        return [
+            actionItem('detail-tab', 'Tab', 'section'),
+            actionItem('detail-edit', 'e', 'edit'),
+            ...ticketCopyActions(),
+            actionItem('detail-arrows', '↑↓', count > 1 ? 'select' : 'scroll'),
+            ...(count > 0
+                ? [actionItem('detail-enter', 'Enter/Space', 'expand')]
+                : []),
+        ];
+    }
+    notice() {
+        return this.status || undefined;
+    }
+    select(index, context) {
+        const next = Math.max(0, Math.min(index, this.view(context).selectable - 1));
+        if (next === this.selectedEntry)
+            return false;
+        this.selectedEntry = next;
+        context.requestDraw();
+        return true;
+    }
+    activate(index, context) {
+        if (!this.view(context).selectable)
+            return false;
+        if (this.expanded.has(index))
+            this.expanded.delete(index);
+        else
+            this.expanded.add(index);
+        context.requestDraw();
+        return true;
+    }
+    handleInput(input, context) {
+        if (super.handleInput(input, context))
+            return true;
+        if (this.state !== 'ready')
+            return false;
+        if (input === 'y' || input === 'Y') {
+            this.status = handleTicketCopy(input, context, this.readyValue) ?? '';
+            context.requestDraw();
+            return true;
+        }
+        if (input === 'enter' || input === ' ')
+            return this.activate(this.selectedEntry, context);
+        const count = this.view(context).selectable;
+        if (count > 1) {
+            if (input === 'down' || input === 'j')
+                return this.select(this.selectedEntry + 1, context);
+            if (input === 'up' || input === 'k')
+                return this.select(this.selectedEntry - 1, context);
+            if (input === 'g')
+                return this.select(0, context);
+            if (input === 'G')
+                return this.select(count - 1, context);
+        }
+        return false;
+    }
+    commandForInput(input) {
+        return this.state === 'ready' && input === 'e'
+            ? 'edit-assignment'
+            : undefined;
+    }
+    actionForInput(input, context) {
+        return this.commandForInput(input)
+            ? ticketEditAction(context, this.readyValue)
+            : undefined;
+    }
+    receiveResult(result, context) {
+        const returned = result;
+        if (returned?.type === 'ticket-assignment-updated' && returned.document) {
+            this.replaceReady(saveTicket(context, returned.document));
+            context.requestDraw();
+        }
+    }
+    renderNonInteractive(context) {
+        return flattenSections(this.sections(context).map((section) => ({
+            ...section,
+            lines: section.expandable
+                ? firstLineSummary(section.lines.map((line) => plainLine(String(line)))).map((line) => line.text)
+                : [...section.lines],
+        }))).lines;
+    }
+    reset() {
+        this.releaseStore?.();
+        this.releaseStore = undefined;
+        super.reset();
+        this.selectedEntry = 0;
+        this.expanded = new Set();
+        this.status = '';
+    }
+}

package/dist/src/preset.d.ts

@@ -0,0 +1,3 @@
+import type { BbPreset } from '@bakers-build/core';
+export declare const uiEntries: BbPreset['uiEntries'];
+export declare const scopes: BbPreset['scopes'];

package/dist/src/preset.js

@@ -0,0 +1,6 @@
+export const uiEntries = (acc) => [
+    ...acc,
+    '@bakers-build/addon-bakers-ui-artifacts/ui',
+];
+// Configurable on either level; the machine entry's with wins.
+export const scopes = ['machine', 'project'];

package/dist/src/tree.d.ts

@@ -0,0 +1,34 @@
+import type { Section } from '@bakers-build/addon-bakers-ui/ui';
+type ArtifactSection = Section & {
+    expandable?: boolean;
+};
+/**
+ * The roots to probe, in order (spec D9).
+ *
+ * Pure path joins: `cwd` comes from `TuiOptions`, `identifier` and `branch` off
+ * the open document, so there is no `git` call and nothing async. The second
+ * root is not a nicety — an operator starts `bakers ui` in the main checkout while
+ * a run writes its artifacts inside the worktree, so probing only the first
+ * would show nothing, systematically.
+ */
+export declare function artifactRoots(cwd: string, identifier: string, branch: string): string[];
+/**
+ * One section per ARTIFACT, headed by its path under the ticket's tree so the
+ * producing tool leads every heading (`vitest/store-green.txt`,
+ * `playwright/logs/walk.txt`) and one tool's artifacts stand together.
+ *
+ * Why per artifact and not per tool directory: the panel contract is
+ * `ArtifactSection[]` with one collapsible entry per section (spec D4), and D9 asks
+ * for each FILE to be the expandable entry — its collapsed row the producing
+ * command, its expanded body the head of the capture. A section per tool could
+ * carry only one of those two, so the grouping lives in the heading instead,
+ * where it costs the narrow contract nothing.
+ *
+ * The first row of every text artifact is its own first line, which by BB-371
+ * D3 is the command that produced it — so the collapsed panel reads as the list
+ * of commands this ticket ran.
+ */
+export declare function artifactSections(roots: readonly string[], { headLines }: {
+    headLines: number;
+}): readonly ArtifactSection[];
+export {};

package/dist/src/tree.js

@@ -0,0 +1,141 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * The roots to probe, in order (spec D9).
+ *
+ * Pure path joins: `cwd` comes from `TuiOptions`, `identifier` and `branch` off
+ * the open document, so there is no `git` call and nothing async. The second
+ * root is not a nicety — an operator starts `bakers ui` in the main checkout while
+ * a run writes its artifacts inside the worktree, so probing only the first
+ * would show nothing, systematically.
+ */
+export function artifactRoots(cwd, identifier, branch) {
+    const own = join(cwd, 'assets-ai', identifier);
+    return branch.trim() === ''
+        ? [own]
+        : [own, join(cwd, '.bakers-worktrees', branch, 'assets-ai', identifier)];
+}
+/**
+ * Text file heads, memoised per `(path, mtime, size)` — spec D9.
+ *
+ * That key is what makes the cache CORRECT rather than merely fast: keying on
+ * the directory's own mtime would go stale the moment a re-run overwrites a log
+ * in place, because rewriting a file does not touch its directory. There is no
+ * reliance on the `R` key either — it reloads the document and knows nothing
+ * about this tree.
+ */
+const heads = new Map();
+const head = (path, lines) => {
+    const stat = statSync(path);
+    const key = `${path}:${stat.mtimeMs}:${stat.size}`;
+    const hit = heads.get(key);
+    if (hit)
+        return hit;
+    const all = readFileSync(path, 'utf8').replace(/\n$/, '').split('\n');
+    const kept = all.slice(0, lines);
+    if (all.length > lines)
+        kept.push(`… ${all.length - lines} more lines`);
+    heads.set(key, kept);
+    return kept;
+};
+/** Extensions never read: their bytes say nothing a terminal can show. */
+const BINARY = /\.(png|jpe?g|gif|webp|zip|pdf|webm|mp4)$/i;
+/**
+ * One directory's entries, or none when it cannot be read.
+ *
+ * A directory that vanished between the walk and the read is not an error worth
+ * a stack trace — this runs on the DRAW path, and a run writing into the tree is
+ * exactly the situation the panel exists for.
+ */
+const entriesOf = (dir) => {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+};
+/**
+ * One FILE's section — and the same reasoning `entriesOf` states, applied to the
+ * calls that actually touch bytes.
+ *
+ * The race that comment names is not hypothetical for a file: a run unlinks or
+ * rewrites a capture between `readdirSync` and this read and the `stat`/`open`
+ * comes back ENOENT; a log written by a container as root comes back EACCES. On
+ * the DRAW path either one used to escape as a stack trace, and the host's guard
+ * would then have degraded the WHOLE listing to a single failure row — so one
+ * unreadable file would hide every artifact beside it. It costs its own row
+ * instead: the file stays listed under its real heading, the row says plainly
+ * that it could not be read, and it is NOT expandable, because there is nothing
+ * behind the caret to show. The errno leads, since `ENOENT`/`EACCES` is the part
+ * that tells the operator whether to re-run or to fix permissions.
+ */
+const fileSection = (heading, path, headLines) => {
+    try {
+        return BINARY.test(heading)
+            ? // Listed, never read — and NOT expandable, because there is nothing
+                // behind the caret a terminal could show.
+                { heading, lines: [`${statSync(path).size} bytes`] }
+            : { heading, expandable: true, lines: [...head(path, headLines)] };
+    }
+    catch (caught) {
+        const code = caught?.code;
+        return {
+            heading,
+            lines: [
+                `could not be read: ${typeof code === 'string'
+                    ? code
+                    : caught instanceof Error
+                        ? caught.message
+                        : String(caught)}`,
+            ],
+        };
+    }
+};
+/**
+ * One section per ARTIFACT, headed by its path under the ticket's tree so the
+ * producing tool leads every heading (`vitest/store-green.txt`,
+ * `playwright/logs/walk.txt`) and one tool's artifacts stand together.
+ *
+ * Why per artifact and not per tool directory: the panel contract is
+ * `ArtifactSection[]` with one collapsible entry per section (spec D4), and D9 asks
+ * for each FILE to be the expandable entry — its collapsed row the producing
+ * command, its expanded body the head of the capture. A section per tool could
+ * carry only one of those two, so the grouping lives in the heading instead,
+ * where it costs the narrow contract nothing.
+ *
+ * The first row of every text artifact is its own first line, which by BB-371
+ * D3 is the command that produced it — so the collapsed panel reads as the list
+ * of commands this ticket ran.
+ */
+export function artifactSections(roots, { headLines }) {
+    const root = roots.find((candidate) => {
+        try {
+            return statSync(candidate).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    if (root === undefined)
+        return [];
+    const sections = [];
+    const walk = (dir, prefix) => {
+        // Sorted by name, so the listing is the same on every draw and on every
+        // filesystem — `readdirSync` promises no order of its own.
+        const sorted = [...entriesOf(dir)].sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of sorted) {
+            const path = join(dir, entry.name);
+            const heading = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
+            if (entry.isDirectory()) {
+                walk(path, heading);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            sections.push(fileSection(heading, path, headLines));
+        }
+    };
+    walk(root, '');
+    return sections;
+}

package/dist/src/ui.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/ui.js

@@ -0,0 +1,6 @@
+// The entry module: it registers at IMPORT time, which is Storybook-faithful for
+// the addon author and is why the kernel drains the collector once rather than
+// handing a store around (spec D3).
+import { register } from '@bakers-build/addon-bakers-ui/ui';
+import { ArtifactsTabScreen } from './panel.js';
+register('bakers/artifacts', (api) => api.add(ArtifactsTabScreen));

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "@bakers-build/addon-bakers-ui-artifacts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-next.38",
+  "description": "bakers.build TUI: an Artifacts tab on ticket detail, reading assets-ai/<bakers.build-nnn>/.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/src/panel.js",
+    "./preset": "./dist/src/preset.js",
+    "./ui": "./dist/src/ui.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://git.key-tec.de/bakers-build/bakers-build.git",
+    "directory": "bakers-cli/addons/bakers-ui-artifacts"
+  },
+  "peerDependencies": {
+    "@bakers-build/addon-bakers-ui": "^0.1.0-next.38",
+    "@bakers-build/core": "^0.1.0-next.38"
+  }
+}