@vzlentin/harness 0.0.0-stage → 0.1.0

package/dist/picker.d.ts

@@ -0,0 +1,22 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { ModelInfo } from "./protocol.ts";
+/**
+ * A filter over a list of models, fuzzy as Pi's model selector: typing narrows the list and keeps the selected model
+ * when it still matches, ↑↓ move, Enter picks, Esc closes.
+ */
+export declare class ModelPicker implements Component {
+    private readonly input;
+    private readonly items;
+    private readonly modelOf;
+    private readonly onSelect;
+    private readonly onCancel;
+    private readonly border;
+    private list;
+    focused: boolean;
+    constructor(models: readonly ModelInfo[], current: ModelInfo | undefined, border: (text: string) => string, onSelect: (model: ModelInfo) => void, onCancel: () => void);
+    /** A frame with full-width lines, so the transcript does not show through. */
+    render(width: number): string[];
+    handleInput(data: string): void;
+    invalidate(): void;
+    private listOf;
+}

package/dist/picker.js

@@ -0,0 +1,70 @@
+import { getSelectListTheme } from "@earendil-works/pi-coding-agent";
+import { fuzzyFilter, Input, matchesKey, SelectList, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+/** The keys that the list of the model picker gets; the filter gets the others. */
+const LIST_KEYS = ["up", "down", "enter", "escape", "pageUp", "pageDown"];
+/**
+ * A filter over a list of models, fuzzy as Pi's model selector: typing narrows the list and keeps the selected model
+ * when it still matches, ↑↓ move, Enter picks, Esc closes.
+ */
+export class ModelPicker {
+    input = new Input();
+    items;
+    modelOf = new Map();
+    onSelect;
+    onCancel;
+    border;
+    list;
+    focused = true;
+    constructor(models, current, border, onSelect, onCancel) {
+        this.items = models.map((model) => {
+            const item = {
+                value: `${model.provider}/${model.id}`,
+                label: `${model.provider}/${model.id}`,
+                description: model.name,
+            };
+            this.modelOf.set(item, model);
+            return item;
+        });
+        this.border = border;
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.input.focused = true;
+        this.list = this.listOf(this.items);
+        this.list.setSelectedIndex(current === undefined ? 0 : models.indexOf(current));
+    }
+    /** A frame with full-width lines, so the transcript does not show through. */
+    render(width) {
+        const inner = Math.max(1, width - 2);
+        const body = [" Model", ...this.input.render(inner), ...this.list.render(inner)].map((line) => {
+            const cut = truncateToWidth(line, inner);
+            return `${this.border("│")}${cut}${" ".repeat(Math.max(0, inner - visibleWidth(cut)))}${this.border("│")}`;
+        });
+        return [this.border(`╭${"─".repeat(inner)}╮`), ...body, this.border(`╰${"─".repeat(inner)}╯`)];
+    }
+    handleInput(data) {
+        if (LIST_KEYS.some((key) => matchesKey(data, key))) {
+            this.list.handleInput(data);
+            return;
+        }
+        this.input.handleInput(data);
+        const selected = this.list.getSelectedItem();
+        const query = this.input.getValue();
+        const items = fuzzyFilter(this.items, query, (item) => `${item.label} ${item.description ?? ""}`);
+        this.list = this.listOf(items);
+        this.list.setSelectedIndex(selected === null ? 0 : items.indexOf(selected));
+    }
+    invalidate() {
+        this.input.invalidate();
+        this.list.invalidate();
+    }
+    listOf(items) {
+        const list = new SelectList(items, 10, getSelectListTheme());
+        list.onSelect = (item) => {
+            const model = this.modelOf.get(item);
+            if (model !== undefined)
+                this.onSelect(model);
+        };
+        list.onCancel = this.onCancel;
+        return list;
+    }
+}

package/dist/projects.d.ts

@@ -0,0 +1,23 @@
+/** The project that has no directory. A cwd outside every project goes to it. */
+export declare const MAIN_PROJECT = "main";
+/** The file of the projects: `$XDG_CONFIG_HOME/harness/projects.json`, default `~/.config/harness/projects.json`. */
+export declare function projectsPath(): string;
+/**
+ * The projects, name to real directory, in creation order. It is empty when the file does not exist. It throws when the
+ * file is not an object of valid names to absolute directories.
+ */
+export declare function readProjects(): Record<string, string>;
+/**
+ * Adds the project `name` with the real path of `dir` to the projects, and gives that path. It throws for an invalid or
+ * existing name and for a directory that does not exist.
+ */
+export declare function addProject(name: string, dir: string): string;
+/** `name` when it is `main` or a project. Otherwise it throws. */
+export declare function checkProject(name: string, projects?: Readonly<Record<string, string>>): string;
+/** The directory of the project `name`: the home directory for `main`. It throws for an unknown project. */
+export declare function projectDir(name: string, projects?: Readonly<Record<string, string>>): string;
+/**
+ * The project of a command: `HARNESS_PROJECT` in `env`, then the project with the longest directory that is `cwd` or
+ * contains it, then `main`. An unknown `HARNESS_PROJECT` is an error.
+ */
+export declare function resolveProject(env: NodeJS.ProcessEnv, cwd: string, projects?: Readonly<Record<string, string>>): string;

package/dist/projects.js

@@ -0,0 +1,93 @@
+import { mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+/** The project that has no directory. A cwd outside every project goes to it. */
+export const MAIN_PROJECT = "main";
+const NAME = /^[a-z][a-z0-9-]{0,31}$/;
+/** The file of the projects: `$XDG_CONFIG_HOME/harness/projects.json`, default `~/.config/harness/projects.json`. */
+export function projectsPath() {
+    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "harness", "projects.json");
+}
+/**
+ * The projects, name to real directory, in creation order. It is empty when the file does not exist. It throws when the
+ * file is not an object of valid names to absolute directories.
+ */
+export function readProjects() {
+    const path = projectsPath();
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+    const projects = JSON.parse(text);
+    if (typeof projects !== "object" || projects === null || Array.isArray(projects)) {
+        throw new Error(`${path} is not an object of project names to directories`);
+    }
+    for (const [name, dir] of Object.entries(projects)) {
+        if (!NAME.test(name) || name === MAIN_PROJECT || typeof dir !== "string" || !isAbsolute(dir)) {
+            throw new Error(`${path} has an invalid project: ${name}`);
+        }
+    }
+    return projects;
+}
+/**
+ * Adds the project `name` with the real path of `dir` to the projects, and gives that path. It throws for an invalid or
+ * existing name and for a directory that does not exist.
+ */
+export function addProject(name, dir) {
+    if (!NAME.test(name))
+        throw new Error(`A project name has 1 to 32 characters: a-z first, then a-z, 0-9 or -: ${name}`);
+    if (name === MAIN_PROJECT)
+        throw new Error(`A project cannot have the name ${name}`);
+    let real;
+    try {
+        real = realpathSync(resolve(dir));
+    }
+    catch {
+        throw new Error(`No such directory: ${dir}`);
+    }
+    if (!statSync(real).isDirectory())
+        throw new Error(`Not a directory: ${dir}`);
+    const projects = readProjects();
+    if (Object.hasOwn(projects, name))
+        throw new Error(`The project ${name} exists (${projects[name]})`);
+    const path = projectsPath();
+    mkdirSync(dirname(path), { recursive: true });
+    // A temporary file, then a rename, so a stop in between does not truncate the projects.
+    const temporary = `${path}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify({ ...projects, [name]: real }, null, "\t")}\n`);
+    renameSync(temporary, path);
+    return real;
+}
+/** `name` when it is `main` or a project. Otherwise it throws. */
+export function checkProject(name, projects = readProjects()) {
+    if (name !== MAIN_PROJECT && !Object.hasOwn(projects, name))
+        throw new Error(`Unknown harness project: ${name}`);
+    return name;
+}
+/** The directory of the project `name`: the home directory for `main`. It throws for an unknown project. */
+export function projectDir(name, projects = readProjects()) {
+    return checkProject(name, projects) === MAIN_PROJECT ? homedir() : projects[name];
+}
+/**
+ * The project of a command: `HARNESS_PROJECT` in `env`, then the project with the longest directory that is `cwd` or
+ * contains it, then `main`. An unknown `HARNESS_PROJECT` is an error.
+ */
+export function resolveProject(env, cwd, projects = readProjects()) {
+    if (env.HARNESS_PROJECT)
+        return checkProject(env.HARNESS_PROJECT, projects);
+    let found = MAIN_PROJECT;
+    let length = -1;
+    for (const [name, dir] of Object.entries(projects)) {
+        // The first project wins over a later one with the same directory.
+        if (dir.length > length && (cwd === dir || cwd.startsWith(dir.endsWith(sep) ? dir : dir + sep))) {
+            found = name;
+            length = dir.length;
+        }
+    }
+    return found;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,232 @@
+import type { Socket } from "node:net";
+import type { JsonValue } from "@earendil-works/chord";
+import type { Op } from "@earendil-works/chord/delta";
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
+import type { ConversationView, TaskId, TaskOutcome, TaskState } from "@earendil-works/pi-durable";
+/** The version of the protocol between the CLI and the host. A client refuses a host with another version. */
+export declare const PROTOCOL_VERSION = 7;
+/**
+ * The handle of the project agent, the host's root conversation, in `watch`, `input`, `abort` and `configure`. It is not
+ * hex, so no child has it.
+ */
+export declare const AGENT_HANDLE = "agent";
+export type ChildState = "busy" | "idle" | "error";
+/** One child as the host reports it. Provider, model and thinking level come from the child's agent. */
+export type ChildInfo = {
+    readonly handle: string;
+    readonly name?: string;
+    readonly state: ChildState;
+    readonly provider: string;
+    readonly model: string;
+    readonly thinking: ModelThinkingLevel;
+    /** The child's working directory. */
+    readonly cwd: string;
+};
+/** A task that `start` created, by its client key. `outcome` is there only when the task is terminal. */
+export type TaskInfo = {
+    readonly key: string;
+    readonly id: TaskId<JsonValue>;
+    /** The name of the task definition. */
+    readonly kind: string;
+    /**
+     * The version on the task's record: the version of the definition that last ran or migrated it, so a client can tell
+     * which version of an entry the host used for this task. A task that no loaded definition can run keeps its version.
+     */
+    readonly version: number;
+    readonly status: TaskState<JsonValue, JsonValue>["status"];
+    readonly outcome?: TaskOutcome<JsonValue>;
+};
+/** A model that the host can run, with what the viewer needs to show and change it. */
+export type ModelInfo = {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+    readonly contextWindow: number;
+    /** The thinking levels of the model, from `off`. */
+    readonly thinkingLevels: readonly ModelThinkingLevel[];
+};
+/** One request line. The caller is `PI_SESSION_ID`, or `cli` without one. */
+export type Request = {
+    readonly type: "hello";
+    readonly version: number;
+} | {
+    readonly type: "spawn";
+    readonly requestId: string;
+    readonly caller: string;
+    readonly name?: string;
+    readonly provider: string;
+    readonly model: string;
+    /** The level the caller asks for; the host refuses it when the model does not have it. */
+    readonly thinking?: string;
+    /** The caller's own level, used without `thinking`, clamped to the nearest level that the model has. */
+    readonly callerThinking: string;
+    readonly cwd: string;
+    readonly tools?: readonly string[];
+    readonly prompt: string;
+} | {
+    readonly type: "send";
+    readonly requestId: string;
+    readonly caller: string;
+    readonly handle: string;
+    readonly message: string;
+    readonly followUp: boolean;
+} | {
+    readonly type: "wait";
+    readonly handle: string;
+    readonly timeout: number;
+} | {
+    readonly type: "status";
+    readonly handle: string;
+} | {
+    readonly type: "list";
+    readonly caller: string;
+} | {
+    readonly type: "rename";
+    readonly caller: string;
+    readonly handle: string;
+    readonly name: string;
+} | {
+    readonly type: "stop";
+    readonly caller: string;
+    readonly handle: string;
+}
+/**
+ * The viewer's stream of the child: the reply, then one `{ event: WatchLine }` line after each commit to the child's
+ * conversation and after each rename. Every other line on the connection stays a reply, in request order. A
+ * connection carries one watch.
+ */
+ | {
+    readonly type: "watch";
+    readonly handle: string;
+}
+/** Stops the child's current turn. The viewer sends it. */
+ | {
+    readonly type: "abort";
+    readonly handle: string;
+}
+/** The models that have a login, for the viewer's model picker and context window. */
+ | {
+    readonly type: "models";
+}
+/**
+ * The viewer's change of the child's model or thinking level. It has no caller. A new model keeps the thinking level
+ * when the model has it, and takes the nearest level that it has otherwise.
+ */
+ | {
+    readonly type: "configure";
+    readonly handle: string;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly thinking?: ModelThinkingLevel;
+}
+/** The viewer's message to the child. It has no caller. */
+ | {
+    readonly type: "input";
+    readonly requestId: string;
+    readonly handle: string;
+    readonly message: string;
+    readonly followUp: boolean;
+}
+/**
+ * Starts a background task of the kind `kind`, a task of an entry in `entries.json`, in the root conversation.
+ * A repeated `key` gives the first task, and its new kind, version and input are ignored. With `version`, a host
+ * whose definition of `kind` has another version refuses before it creates anything.
+ */
+ | {
+    readonly type: "start";
+    readonly kind: string;
+    readonly input: JsonValue;
+    readonly key: string;
+    readonly version?: number;
+} | {
+    readonly type: "task";
+    readonly key: string;
+}
+/** Waits until the task is terminal, and replies with its outcome. A client polls `task` for the status. */
+ | {
+    readonly type: "wait-task";
+    readonly key: string;
+}
+/** Aborts the task and the work that it owns. */
+ | {
+    readonly type: "abort-task";
+    readonly key: string;
+};
+/** The value of the reply to each request type. */
+export type Replies = {
+    readonly hello: {
+        readonly version: number;
+        readonly pid: number;
+    };
+    readonly spawn: ChildInfo;
+    readonly send: {
+        readonly verb: string;
+        readonly child: ChildInfo;
+    };
+    readonly wait: {
+        readonly answer: string;
+    };
+    readonly status: ChildInfo;
+    readonly list: readonly ChildInfo[];
+    readonly rename: ChildInfo;
+    readonly stop: {
+        readonly handle: string;
+        readonly name?: string;
+    };
+    readonly watch: {
+        readonly view: ConversationView;
+        readonly child: ChildInfo;
+    };
+    readonly abort: ChildInfo;
+    readonly input: Replies["send"];
+    readonly models: readonly ModelInfo[];
+    readonly configure: ChildInfo;
+    readonly start: TaskInfo;
+    readonly task: TaskInfo;
+    readonly "wait-task": TaskInfo;
+    readonly "abort-task": TaskInfo;
+};
+/**
+ * An event of a watch after its reply, sent as `{ event: WatchLine }`: the changes of one commit or a rename, or the end
+ * when the child was stopped.
+ */
+export type WatchLine = {
+    readonly ops: readonly Op[];
+    readonly child: ChildInfo;
+    readonly stopped?: undefined;
+} | {
+    readonly stopped: true;
+};
+/** One reply line. */
+export type Reply = {
+    readonly ok: true;
+    readonly value: unknown;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** The files of the host of `project`: `$XDG_STATE_HOME/harness/<project>/`, default `~/.local/state/harness/<project>/`. */
+/**
+ * The CLI of this install, which the host start and the Herdr tabs run with this Node: `cli.js` next to the built
+ * modules, or `cli.ts` in a checkout, which Node runs with type stripping.
+ */
+export declare function cliPath(): string;
+export declare function statePaths(project: string): {
+    dir: string;
+    socket: string;
+    log: string;
+};
+export declare function isValidRunName(value: unknown): value is string;
+/** The label of a child: its name, or its handle when it has no name. */
+export declare function childLabel(child: {
+    readonly handle: string;
+    readonly name?: string | undefined;
+}): string;
+export declare function runDisplayName(metadata: {
+    readonly handle: string;
+    readonly name?: string | undefined;
+}): string;
+/** The line of one child in a list. */
+export declare function childLine(child: ChildInfo): string;
+/** Calls `onLine` with each line that arrives on `socket`, without its newline. */
+export declare function onLines(socket: Socket, onLine: (line: string) => void): void;

package/dist/protocol.js

@@ -0,0 +1,54 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** The version of the protocol between the CLI and the host. A client refuses a host with another version. */
+export const PROTOCOL_VERSION = 7;
+/**
+ * The handle of the project agent, the host's root conversation, in `watch`, `input`, `abort` and `configure`. It is not
+ * hex, so no child has it.
+ */
+export const AGENT_HANDLE = "agent";
+/** The files of the host of `project`: `$XDG_STATE_HOME/harness/<project>/`, default `~/.local/state/harness/<project>/`. */
+/**
+ * The CLI of this install, which the host start and the Herdr tabs run with this Node: `cli.js` next to the built
+ * modules, or `cli.ts` in a checkout, which Node runs with type stripping.
+ */
+export function cliPath() {
+    return fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./cli.ts" : "./cli.js", import.meta.url));
+}
+export function statePaths(project) {
+    const dir = join(process.env.XDG_STATE_HOME || join(homedir(), ".local", "state"), "harness", project);
+    return { dir, socket: join(dir, "host.sock"), log: join(dir, "host.log") };
+}
+export function isValidRunName(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 64 &&
+        value.trim() === value &&
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: a name must not contain control characters.
+        !/[\u0000-\u001f\u007f]/.test(value));
+}
+/** The label of a child: its name, or its handle when it has no name. */
+export function childLabel(child) {
+    return child.name ?? child.handle;
+}
+export function runDisplayName(metadata) {
+    return metadata.name ? `${metadata.name} (${metadata.handle})` : metadata.handle;
+}
+/** The line of one child in a list. */
+export function childLine(child) {
+    return `${runDisplayName(child)}  ${child.state.padEnd(8)}  ${child.provider}/${child.model}  ${child.thinking}`;
+}
+/** Calls `onLine` with each line that arrives on `socket`, without its newline. */
+export function onLines(socket, onLine) {
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+        buffer += chunk;
+        for (let end = buffer.indexOf("\n"); end !== -1; end = buffer.indexOf("\n")) {
+            const line = buffer.slice(0, end);
+            buffer = buffer.slice(end + 1);
+            onLine(line);
+        }
+    });
+}

package/dist/tasks.d.ts

@@ -0,0 +1,31 @@
+import type { AnyTask, Conversation, Extension, Harness } from "@earendil-works/pi-durable";
+import type { Request, TaskInfo } from "./protocol.ts";
+/** What the task requests use of the host. */
+export type TaskHost = {
+    readonly harness: Harness;
+    /** The root conversation, which owns the started tasks. */
+    readonly root: Conversation;
+    /** The tasks that `start` can create, from `startableTasks`. */
+    readonly startable: Extension;
+    /** Aborted when the connection of the request closes. */
+    readonly signal: AbortSignal;
+};
+/**
+ * The extension of the tasks of the entries, which is the list of the kinds that `start` can create. The
+ * registry refuses a task name that two entries give.
+ */
+export declare function startableTasks(tasks: readonly AnyTask[]): Extension;
+/**
+ * Starts the task of `request.key` once. It is a background task of the root conversation, so an abort of the project
+ * agent's turn does not reach it. The key is written in the commit that creates the task, so a start after a crash
+ * finds it.
+ */
+export declare function startTask(host: TaskHost, request: Extract<Request, {
+    type: "start";
+}>): Promise<TaskInfo>;
+/** The info of the task that `start` created for `key`. */
+export declare function taskInfo(harness: Harness, key: string): Promise<TaskInfo>;
+/** Waits until the task of `key` is terminal, or the connection closes, and gives its info with the outcome. */
+export declare function waitTask(host: TaskHost, key: string): Promise<TaskInfo>;
+/** Aborts the task of `key`. The abort reaches the conversations that the task owns, and their turns. */
+export declare function abortTask(harness: Harness, key: string): Promise<TaskInfo>;

package/dist/tasks.js

@@ -0,0 +1,78 @@
+import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
+import * as durable from "@earendil-works/pi-durable";
+const context = BACKGROUND_CONTEXT;
+/** The tasks that `start` created, by client key. A key is never removed. */
+const StartedTasks = durable.defineDoc({
+    kind: "harness.tasks",
+    version: 1,
+    scope: "session",
+    initial: () => ({ tasks: {} }),
+});
+/**
+ * The extension of the tasks of the entries, which is the list of the kinds that `start` can create. The
+ * registry refuses a task name that two entries give.
+ */
+export function startableTasks(tasks) {
+    return durable.defineExtension({ name: "harness-entry-tasks", tasks });
+}
+/**
+ * Starts the task of `request.key` once. It is a background task of the root conversation, so an abort of the project
+ * agent's turn does not reach it. The key is written in the commit that creates the task, so a start after a crash
+ * finds it.
+ */
+export async function startTask(host, request) {
+    await host.root.commit(async (tx) => {
+        const state = await tx.doc(StartedTasks);
+        if (Object.hasOwn(state.tasks, request.key))
+            return;
+        const task = startableTask(host.startable, request.kind);
+        if (request.version !== undefined && task.definition.version !== request.version) {
+            throw new Error(`This host has version ${task.definition.version} of ${request.kind}, not ${request.version}: stop the host so it starts again with the installed version`);
+        }
+        state.tasks[request.key] = await tx.createTask(task, request.input, {
+            ownership: { kind: "conversation" },
+            background: true,
+        });
+    }, context);
+    return taskInfo(host.harness, request.key);
+}
+/** The info of the task that `start` created for `key`. */
+export async function taskInfo(harness, key) {
+    const id = await taskId(harness, key);
+    const record = await harness.getTask(id, context);
+    if (record === undefined)
+        throw new Error(`Missing task ${id}`);
+    return {
+        key,
+        id,
+        kind: record.kind,
+        version: record.version,
+        status: record.state.status,
+        ...(record.state.status === "terminal" ? { outcome: record.state.outcome } : {}),
+    };
+}
+/** Waits until the task of `key` is terminal, or the connection closes, and gives its info with the outcome. */
+export async function waitTask(host, key) {
+    await host.harness.waitForTask(await taskId(host.harness, key), withAbortSignal(host.signal, context));
+    return taskInfo(host.harness, key);
+}
+/** Aborts the task of `key`. The abort reaches the conversations that the task owns, and their turns. */
+export async function abortTask(harness, key) {
+    await harness.abortTask(await taskId(harness, key), context);
+    return taskInfo(harness, key);
+}
+/** The ID of the task that `start` created for `key`. */
+async function taskId(harness, key) {
+    const state = await harness.snapshot(StartedTasks, context);
+    const id = state != null && Object.hasOwn(state.tasks, key) ? state.tasks[key] : undefined;
+    if (id === undefined)
+        throw new Error(`Unknown task: ${key}`);
+    return id;
+}
+/** The task of `kind` in `startable`. The entries give erased tasks, so this is where they get the type of `createTask`. */
+function startableTask(startable, kind) {
+    const task = startable.tasks?.find((found) => found.definition.name === kind);
+    if (task === undefined)
+        throw new Error(`Unknown task kind: ${kind}`);
+    return task;
+}

package/dist/theme.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+export declare function color(name: Parameters<Theme["fg"]>[0], text: string): string;
+export declare function bold(text: string): string;

package/dist/theme.js

@@ -0,0 +1,18 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// Pi gives its theme object only to extensions. Pi's cards color with the theme that `initTheme()` sets in this module,
+// so the viewer loads the same module by its path to color its own lines the same way. The path is not in the `exports`
+// of pi-coding-agent, so it holds only for the pinned version 1.3.0.
+const piTheme = (await import(__rewriteRelativeImportExtension(new URL("./modes/interactive/theme/theme.js", import.meta.resolve("@earendil-works/pi-coding-agent")).href)));
+export function color(name, text) {
+    return piTheme.theme.fg(name, text);
+}
+export function bold(text) {
+    return piTheme.theme.bold(text);
+}