@vzlentin/harness 0.3.0 → 0.4.0

package/pi/chat.ts

@@ -1,286 +0,0 @@
-/**
- * A durable conversation drawn with Pi's own message and tool components.
- *
- * Adapted from `ChatView` in mavam/pi-agents, src/ui/attach.ts. MIT License, Copyright (c) 2026 Matthias Vallentin.
- */
-import type { AssistantMessage, JsonObject, ToolResultMessage } from "@earendil-works/pi-ai";
-import {
-	AssistantMessageComponent,
-	createBashToolDefinition,
-	createEditToolDefinition,
-	createFindToolDefinition,
-	createGrepToolDefinition,
-	createLsToolDefinition,
-	createReadToolDefinition,
-	createWriteToolDefinition,
-	getMarkdownTheme,
-	type ThemeColor,
-	type ToolDefinition,
-	ToolExecutionComponent,
-	UserMessageComponent,
-} from "@earendil-works/pi-coding-agent";
-import type { ConversationView, EntryRecord } from "@earendil-works/pi-durable";
-import { Container, Spacer, Text, type TUI } from "@earendil-works/pi-tui";
-import { liveOf, userText } from "../dist/view-state.js";
-
-// Pi's tool definitions differ in their schemas.
-type AnyDefinition = ToolDefinition<any, any>;
-
-/** Pi's renderers of the tools that children have under the same names. */
-const RENDERERS = new Map<string, (cwd: string) => AnyDefinition>([
-	["read", createReadToolDefinition],
-	["bash", createBashToolDefinition],
-	["edit", createEditToolDefinition],
-	["write", createWriteToolDefinition],
-	["grep", createGrepToolDefinition],
-	["find", createFindToolDefinition],
-	["ls", createLsToolDefinition],
-]);
-
-const DIAGNOSTICS = /^<harness>\n([\s\S]*)\n<\/harness>$/;
-
-/**
- * A tool result as Pi shows its own. pi-durable adds the diagnostics of a call for the model as a `<harness>` block, such
- * as `Command exited with code 3`, and the card shows them as plain lines.
- */
-export function displayedResult(result: ToolResultMessage): ToolResultMessage {
-	let changed = false;
-
-	const content = result.content.map((block) => {
-		const match = block.type === "text" ? DIAGNOSTICS.exec(block.text) : null;
-
-		if (!match) return block;
-		changed = true;
-		const lines = (match[1] ?? "").split("\n").map((line) => line.replace(/^\[(error|warning|info)\] /, ""));
-
-		return { type: "text" as const, text: `\n${lines.join("\n")}` };
-	});
-
-	return changed ? { ...result, content } : result;
-}
-
-/** The transcript of one conversation view, updated in place as the view changes. */
-export class ChatView {
-	readonly transcript = new Container();
-	/** The newest card for each call ID: providers can use a call ID again in a later turn. */
-	private readonly tools = new Map<string, ToolExecutionComponent>();
-	/** Every card shown, also the older ones whose call ID a later turn used again. */
-	private readonly cards: ToolExecutionComponent[] = [];
-	/** The cards that have no final result yet. */
-	private readonly running = new Set<ToolExecutionComponent>();
-	/** The call IDs whose cards the streamed answer made; its entry takes them over. */
-	private readonly streamingCalls = new Set<string>();
-	private readonly renderers = new Map<string, AnyDefinition>();
-	private renderedEntryIds: EntryRecord["id"][] = [];
-	private streaming: AssistantMessageComponent | undefined;
-	/** Ctrl+O shows tool output in full, as in Pi. */
-	private expanded = false;
-	/** Pi's `hideThinkingBlock` setting: the answers show a label in place of their thinking. */
-	private hideThinking = false;
-	private readonly ui: TUI;
-	private readonly cwd: string;
-	/** Colors the lines that the transcript adds itself, such as `[compaction]`, in Pi's current theme. */
-	private readonly color: (name: ThemeColor, text: string) => string;
-
-	constructor(ui: TUI, cwd: string, color: (name: ThemeColor, text: string) => string) {
-		this.ui = ui;
-		this.cwd = cwd;
-		this.color = color;
-	}
-
-	apply(view: ConversationView): void {
-		const live = liveOf(view);
-		this.syncTranscript(view.entries);
-		const message = live.generation?.message;
-
-		// A streamed answer without its entry was dropped, for example by a retry.
-		if (message === undefined && this.streaming !== undefined) this.rebuild(view.entries);
-
-		if (message !== undefined) this.syncStreaming(message);
-
-		for (const slot of live.tools ?? []) {
-			if (slot.status === "pending") continue;
-			const component = this.card(slot.name, slot.callId);
-			component.setArgsComplete();
-
-			if (slot.status !== "running") continue;
-			component.markExecutionStarted();
-
-			if (slot.output !== undefined || slot.details !== undefined) {
-				component.updateResult(
-					{ content: [{ type: "text", text: slot.output ?? "" }], details: slot.details, isError: false },
-					true,
-				);
-			}
-		}
-
-		this.transcript.invalidate();
-	}
-
-	/** Shows tool output in full when `expanded` is true, else collapsed. */
-	setExpanded(expanded: boolean): void {
-		this.expanded = expanded;
-
-		for (const card of this.cards) card.setExpanded(expanded);
-		this.transcript.invalidate();
-	}
-
-	/** Hides the thinking of the answers when `hide` is true, else shows it. */
-	setHideThinking(hide: boolean): void {
-		this.hideThinking = hide;
-
-		for (const child of this.transcript.children) {
-			if (child instanceof AssistantMessageComponent) child.setHideThinkingBlock(hide);
-		}
-
-		this.transcript.invalidate();
-	}
-
-	/** Finishes the running cards: a running bash card keeps a timer until it gets a final result. */
-	stopTimers(): void {
-		for (const component of this.running) component.updateResult({ content: [], isError: false }, false);
-		this.running.clear();
-	}
-
-	private syncTranscript(entries: readonly EntryRecord[]): void {
-		// A compaction or a reset replaces the head of the active transcript.
-		if (this.renderedEntryIds.some((id, index) => entries[index]?.id !== id)) this.rebuild(entries);
-
-		for (const entry of entries.slice(this.renderedEntryIds.length)) {
-			this.addEntry(entry);
-			this.renderedEntryIds.push(entry.id);
-		}
-	}
-
-	private rebuild(entries: readonly EntryRecord[]): void {
-		this.stopTimers();
-		this.transcript.clear();
-		this.cards.length = 0;
-		this.tools.clear();
-		this.streamingCalls.clear();
-		this.renderedEntryIds = [];
-		this.streaming = undefined;
-
-		for (const entry of entries) {
-			this.addEntry(entry);
-			this.renderedEntryIds.push(entry.id);
-		}
-	}
-
-	private addEntry(entry: EntryRecord): void {
-		const message = entry.model?.[0];
-
-		if (entry.kind === "pi.user" && message?.role === "user") {
-			this.transcript.addChild(new Spacer(1));
-			this.transcript.addChild(new UserMessageComponent(userText(message.content), getMarkdownTheme()));
-		} else if (entry.kind === "pi.assistant" && message?.role === "assistant") {
-			const component =
-				this.streaming ?? new AssistantMessageComponent(undefined, this.hideThinking, getMarkdownTheme());
-
-			if (this.streaming === undefined) this.transcript.addChild(component);
-			this.streaming = undefined;
-			component.updateContent(message, false);
-			// Only an answer that asks for tools runs its calls; an aborted, failed or cut answer never does.
-			const ran = message.stopReason === "toolUse";
-
-			for (const content of message.content) {
-				if (content.type !== "toolCall") continue;
-				const streamed = this.streamingCalls.has(content.id);
-
-				if (!ran && !streamed) continue;
-
-				const card = streamed
-					? this.card(content.name, content.id, content.arguments)
-					: this.newCard(content.name, content.id, content.arguments);
-
-				card.setArgsComplete();
-
-				if (!ran) {
-					const text = "Not run: the answer was interrupted.";
-					card.updateResult({ content: [{ type: "text", text }], isError: true }, false);
-					this.running.delete(card);
-				}
-			}
-
-			this.streamingCalls.clear();
-		} else if (entry.kind === "pi.tool-result" && message?.role === "toolResult") {
-			const card = this.card(message.toolName, message.toolCallId);
-			card.updateResult(displayedResult(message));
-			this.running.delete(card);
-		} else if (entry.kind === "pi.compaction") {
-			this.addText(this.color("muted", "[compaction]"));
-
-			if (message?.role === "user") this.addText(userText(message.content));
-		} else if (entry.kind === "pi.reset") {
-			this.addText(this.color("muted", "[new context]"));
-		}
-	}
-
-	private syncStreaming(message: AssistantMessage): void {
-		if (this.streaming === undefined) {
-			this.streaming = new AssistantMessageComponent(undefined, this.hideThinking, getMarkdownTheme());
-			this.transcript.addChild(this.streaming);
-		}
-
-		this.streaming.updateContent(message, true);
-
-		for (const content of message.content) {
-			if (content.type !== "toolCall") continue;
-
-			if (this.streamingCalls.has(content.id)) this.card(content.name, content.id, content.arguments);
-			else this.newCard(content.name, content.id, content.arguments);
-			this.streamingCalls.add(content.id);
-		}
-	}
-
-	private renderer(toolName: string): AnyDefinition | undefined {
-		let definition = this.renderers.get(toolName);
-
-		if (definition === undefined) {
-			const create = RENDERERS.get(toolName);
-
-			if (create === undefined) return undefined;
-			definition = create(this.cwd);
-			this.renderers.set(toolName, definition);
-		}
-
-		return definition;
-	}
-
-	/** The newest card of a call, or a new card when the call has none. */
-	private card(toolName: string, toolCallId: string, args?: JsonObject): ToolExecutionComponent {
-		const existing = this.tools.get(toolCallId);
-
-		if (existing === undefined) return this.newCard(toolName, toolCallId, args ?? {});
-
-		if (args !== undefined) existing.updateArgs(args);
-
-		return existing;
-	}
-
-	/** A new card of a call, also for a call ID that an earlier turn used. */
-	private newCard(toolName: string, toolCallId: string, args: JsonObject): ToolExecutionComponent {
-		const component = new ToolExecutionComponent(
-			toolName,
-			toolCallId,
-			args,
-			{},
-			this.renderer(toolName),
-			this.ui,
-			this.cwd,
-		);
-
-		component.setExpanded(this.expanded);
-		this.transcript.addChild(component);
-		this.cards.push(component);
-		this.running.add(component);
-		this.tools.set(toolCallId, component);
-
-		return component;
-	}
-
-	private addText(text: string): void {
-		this.transcript.addChild(new Spacer(1));
-		this.transcript.addChild(new Text(text, 1, 0));
-	}
-}

package/pi/index.ts

@@ -1,170 +0,0 @@
-/**
- * The `subagent` tool, `/subagent`, the subagents widget and the mirror sessions of `/harness`. They use the client of
- * the harness package that holds this folder, from its built `dist/`, and start the host of that package.
- */
-import { resolve } from "node:path";
-import { Type } from "@earendil-works/pi-ai";
-import {
-	type ExtensionAPI,
-	type ExtensionContext,
-	getAgentDir,
-	hasTrustRequiringProjectResources,
-	ProjectTrustStore,
-	SettingsManager,
-} from "@earendil-works/pi-coding-agent";
-import { request } from "../dist/client.js";
-import { inHerdr, openChildTab } from "../dist/herdr.js";
-import { childLine, errorMessage, runDisplayName } from "../dist/protocol.js";
-import * as tool from "../dist/tool.js";
-import { registerMirror } from "./mirror.ts";
-
-const SESSION_TRUST_HINT =
-	"The child gets no project skills (.pi/skills, .agents/skills): this project is trusted for this Pi session only, and children see only the trust saved for future sessions. To give children project skills, run /trust and choose Trust.";
-
-export default function subagentExtension(pi: ExtensionAPI) {
-	registerMirror(pi);
-	const { parameters, output } = tool.toolSchemas(Type);
-	pi.registerTool({
-		name: "subagent",
-		label: "Subagent",
-		description: tool.TOOL_DESCRIPTION,
-		parameters,
-		outputSchema: output,
-		executionMode: "sequential",
-		async execute(toolCallId, args, signal, _onUpdate, ctx) {
-			const { text, data } = await tool.runTool(args, {
-				caller: ctx.sessionManager.getSessionId(),
-				callKey: toolCallId,
-				provider: ctx.model?.provider,
-				model: ctx.model?.id,
-				thinking: pi.getThinkingLevel(),
-				cwd: ctx.cwd,
-				send: tool.sendToHost,
-				signal,
-			});
-
-			// Children follow only the saved trust, so a session that trusts its project for itself says what the child misses.
-			const sessionOnly =
-				args.action === "spawn" &&
-				ctx.isProjectTrusted() &&
-				!savedTrust(ctx.cwd) &&
-				!savedTrust(resolve(ctx.cwd, args.cwd ?? "."));
-
-			const hint = sessionOnly ? `\n${SESSION_TRUST_HINT}\n` : "";
-
-			return { content: [{ type: "text", text: text + hint }], details: undefined, structuredContent: data };
-		},
-	});
-
-	pi.registerCommand("subagent", {
-		description: "Open a subagent spawned by this session in Pi, in a new Herdr tab",
-		handler: async (_args, ctx) => {
-			const children = await request({ type: "list", caller: ctx.sessionManager.getSessionId() }, { start: true });
-
-			if (children.length === 0) {
-				ctx.ui.notify("No subagents spawned by this session", "info");
-
-				return;
-			}
-
-			const chosen = await ctx.ui.select("Attach to subagent", children.map(childLine));
-
-			// A name can start with the display name of another child, so the longest match is the chosen child.
-			const child = children
-				.filter((c: { handle: string; name?: string }) => chosen?.startsWith(`${runDisplayName(c)}  `))
-				.sort(
-					(a: { handle: string; name?: string }, b: { handle: string; name?: string }) =>
-						runDisplayName(b).length - runDisplayName(a).length,
-				)[0];
-
-			if (child === undefined) return;
-			const command = `harness attach ${child.handle}`;
-
-			if (!inHerdr(process.env)) {
-				ctx.ui.notify(`Run in another terminal: ${command}`, "info");
-
-				return;
-			}
-
-			try {
-				await openChildTab(child, process.env);
-			} catch (error) {
-				const message = errorMessage(error);
-				ctx.ui.notify(`Could not open a Herdr tab: ${message}. Run in another terminal: ${command}`, "error");
-			}
-		},
-	});
-
-	let widgetTimer: ReturnType<typeof setInterval> | undefined;
-	let widgetContext: ExtensionContext | undefined;
-	let refreshing = false;
-
-	// The widget does not start the host: when none runs, it shows nothing.
-	const refreshWidget = async (): Promise<void> => {
-		if (!widgetContext || refreshing) return;
-		refreshing = true;
-
-		try {
-			const context = widgetContext;
-
-			const children = await request(
-				{ type: "list", caller: context.sessionManager.getSessionId() },
-				{ start: false },
-			).catch(() => undefined);
-
-			if (context !== widgetContext) return;
-
-			if (children === undefined || children.length === 0) {
-				context.ui.setWidget("subagents", undefined);
-
-				return;
-			}
-
-			const theme = context.ui.theme;
-
-			const visible = children
-				.slice(0, 5)
-				.map(({ name, handle, state }: { name?: string; handle: string; state: string }) => {
-					const color = state === "busy" ? "warning" : state === "idle" ? "success" : "error";
-
-					return theme.fg(color, `${name ?? handle}:${state}`);
-				});
-
-			if (children.length > visible.length) visible.push(theme.fg("muted", `+${children.length - visible.length}`));
-			context.ui.setWidget("subagents", [theme.fg("dim", "subagents: ") + visible.join(theme.fg("dim", " | "))], {
-				placement: "belowEditor",
-			});
-		} finally {
-			refreshing = false;
-		}
-	};
-
-	pi.on("session_start", (_event, ctx) => {
-		if (!ctx.hasUI) return;
-		widgetContext = ctx;
-		void refreshWidget();
-		widgetTimer = setInterval(() => void refreshWidget(), 1000);
-		widgetTimer.unref();
-	});
-
-	pi.on("session_shutdown", (_event, ctx) => {
-		if (widgetTimer) clearInterval(widgetTimer);
-		widgetTimer = undefined;
-		widgetContext = undefined;
-		ctx.ui.setWidget("subagents", undefined);
-	});
-}
-
-/**
- * Whether Pi trusts the project in `cwd` with no one to ask, as the host does in `src/trust.ts` of harness. It is here
- * with Pi's own modules, so Pi does not load the copy of pi-coding-agent that harness installs.
- */
-function savedTrust(cwd: string): boolean {
-	if (!hasTrustRequiringProjectResources(cwd)) return true;
-	const agentDir = getAgentDir();
-	const decision = new ProjectTrustStore(agentDir).get(cwd);
-
-	if (decision !== null) return decision;
-
-	return SettingsManager.create(cwd, agentDir, { projectTrusted: false }).getDefaultProjectTrust() === "always";
-}

package/pi/mirror.ts

@@ -1,206 +0,0 @@
-/**
- * Mirror sessions: a Pi session that shows a child or the agent of a harness project in Pi's own chat, and sends what
- * the user types to it. The agent runs in the host of the project; the session keeps only its target, in one custom
- * entry. `/harness [project]` opens one in a new session, and `pi --harness <project> [--harness-child <handle>]` in the
- * session that Pi starts with.
- */
-
-import { homedir } from "node:os";
-import type {
-	ExtensionAPI,
-	ExtensionCommandContext,
-	ExtensionContext,
-	SessionEntry,
-} from "@earendil-works/pi-coding-agent";
-import type { AutocompleteItem } from "@earendil-works/pi-tui";
-import * as tui from "@earendil-works/pi-tui";
-import { isMirrorTarget, MIRROR_ENTRY, type MirrorTarget, PI_FLAGS } from "../dist/mirror.js";
-import { checkProject, MAIN_PROJECT, projectDir, readProjects, resolveProject } from "../dist/projects.js";
-import { AGENT_HANDLE, errorMessage } from "../dist/protocol.js";
-import { Attachment } from "./attachment.ts";
-
-/** The mirror entry of a session: its ID and its target. */
-type MirrorEntry = { readonly id: string; readonly target: MirrorTarget };
-
-/** Registers `/harness`, `--harness` and the handlers that turn a session with a mirror entry into a mirror session. */
-export function registerMirror(pi: ExtensionAPI): void {
-	// The frame of each mirror entry in Pi's chat. Pi can draw the entry before or after `session_start`.
-	const frames = new Map<string, tui.Container>();
-	let attached: Attachment | undefined;
-
-	const frameOf = (entryId: string): tui.Container => {
-		const frame = frames.get(entryId) ?? new tui.Container();
-		frames.set(entryId, frame);
-
-		return frame;
-	};
-
-	pi.registerFlag(PI_FLAGS.project, {
-		type: "string",
-		description: "Show the agent of this harness project (main or a project name) in the new session",
-	});
-
-	pi.registerFlag(PI_FLAGS.child, {
-		type: "string",
-		description: "Show this subagent of the harness project in the new session, in place of the project agent",
-	});
-
-	pi.registerEntryRenderer(MIRROR_ENTRY, (entry, options, theme) => {
-		if (attached?.entryId === entry.id) attached.restyle(theme, options.expanded);
-
-		return frameOf(entry.id);
-	});
-
-	pi.registerCommand("harness", {
-		description: "Show the agent of a harness project in a new session: /harness [project]",
-		getArgumentCompletions: projectItems,
-		handler: async (args, ctx) => {
-			let project: string | undefined;
-
-			try {
-				project = args.trim() === "" ? await pickProject(ctx) : checkProject(args.trim());
-			} catch (error) {
-				ctx.ui.notify(`harness: ${errorMessage(error)}`, "error");
-
-				return;
-			}
-
-			if (project === undefined) return;
-			const target: MirrorTarget = { project, handle: AGENT_HANDLE };
-			await ctx.newSession({
-				setup: async (sessionManager) => {
-					sessionManager.appendCustomEntry(MIRROR_ENTRY, target);
-				},
-			});
-		},
-	});
-
-	pi.on("session_start", (event, ctx) => {
-		if (ctx.mode !== "tui") return;
-		const branch = ctx.sessionManager.getBranch();
-
-		// Pi draws only the entries of this branch from now on. A /reload keeps the session, and its frames.
-		for (const id of frames.keys()) {
-			if (!branch.some((entry) => entry.id === id)) frames.delete(id);
-		}
-
-		const entry = mirrorEntry(branch) ?? (event.reason === "startup" ? flagEntry(pi, ctx) : undefined);
-
-		if (entry !== undefined) attached = new Attachment(pi, ctx, entry.id, entry.target, frameOf(entry.id));
-	});
-
-	pi.on("session_shutdown", () => {
-		attached?.close();
-		attached = undefined;
-	});
-
-	// The agent of the host answers in a mirror session, so the input goes there and not to Pi's own agent.
-	pi.on("input", (event, ctx) => {
-		if (attached === undefined) return undefined;
-
-		if (event.images !== undefined && event.images.length > 0) {
-			ctx.ui.notify("harness: the images are not sent; the agent gets only the text", "warning");
-		}
-
-		attached.send(event.text, false);
-
-		return { action: "handled" };
-	});
-
-	// A restored model is the one of the Pi session, not a choice of the user.
-	pi.on("model_select", (event) => {
-		if (event.source !== "restore") attached?.models.piSelected(event.model.provider, event.model.id);
-	});
-}
-
-/** The newest mirror entry of `entries` with a valid target. */
-function mirrorEntry(entries: readonly SessionEntry[]): MirrorEntry | undefined {
-	for (const entry of entries.toReversed()) {
-		if (entry.type === "custom" && entry.customType === MIRROR_ENTRY && isMirrorTarget(entry.data)) {
-			return { id: entry.id, target: entry.data };
-		}
-	}
-
-	return undefined;
-}
-
-/**
- * The mirror entry for `--harness <project>` and `--harness-child <handle>`, written in the session that Pi starts
- * with. Without a project, it is the project of `HARNESS_PROJECT` and Pi's working directory; without a child, the
- * project agent. It refuses a session with messages, such as one of `--continue`, because Pi's own agent answered there.
- */
-function flagEntry(pi: ExtensionAPI, ctx: ExtensionContext): MirrorEntry | undefined {
-	const project = stringFlag(pi, PI_FLAGS.project);
-	const child = stringFlag(pi, PI_FLAGS.child);
-
-	if (project === undefined && child === undefined) return undefined;
-
-	if (ctx.sessionManager.getBranch().some((entry) => entry.type === "message")) {
-		ctx.ui.notify("harness: --harness needs a new session, not one with messages", "error");
-
-		return undefined;
-	}
-
-	let target: MirrorTarget;
-
-	try {
-		target = {
-			project: project ? checkProject(project) : resolveProject(process.env, ctx.cwd),
-			handle: child || AGENT_HANDLE,
-		};
-	} catch (error) {
-		ctx.ui.notify(`harness: ${errorMessage(error)}`, "error");
-
-		return undefined;
-	}
-
-	// `appendEntry` gives no entry ID, so the entry comes back from the branch.
-	pi.appendEntry(MIRROR_ENTRY, target);
-
-	return mirrorEntry(ctx.sessionManager.getBranch());
-}
-
-/** The value of the string flag `name`, or undefined when it is not given. */
-function stringFlag(pi: ExtensionAPI, name: string): string | undefined {
-	const flag = pi.getFlag(name);
-
-	return flag === undefined || flag === true || flag === false ? undefined : flag;
-}
-
-/**
- * The project that the user selects for `/harness` without a project: the project of Pi's working directory first,
- * then the other projects and `main`. It is undefined when the user cancels.
- */
-async function pickProject(ctx: ExtensionCommandContext): Promise<string | undefined> {
-	const projects = readProjects();
-	const current = resolveProject(process.env, ctx.cwd, projects);
-	const names = [current, ...[...Object.keys(projects), MAIN_PROJECT].filter((name) => name !== current)];
-
-	if (names.length === 1) return current;
-	const labels = names.map((name) => `${name}  ${tildePath(projectDir(name, projects))}`);
-	const label = await ctx.ui.select("Harness project", labels);
-
-	return label === undefined ? undefined : names[labels.indexOf(label)];
-}
-
-/** `path` with the home directory as `~`. */
-function tildePath(path: string): string {
-	const home = homedir();
-
-	return home !== "" && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
-}
-
-/** The projects whose names start with `prefix`, for the argument of `/harness`. */
-function projectItems(prefix: string): AutocompleteItem[] | null {
-	let names: string[];
-
-	try {
-		names = [...Object.keys(readProjects()), MAIN_PROJECT];
-	} catch {
-		return null;
-	}
-
-	const items = names.flatMap((name) => (name.startsWith(prefix) ? [{ value: name, label: name }] : []));
-
-	return items.length > 0 ? items : null;
-}