pi-extension-utils 0.3.0 → 0.3.2

package/README.md

@@ -1,46 +1,109 @@
 # pi-extension-utils
 
-Shared utilities for Pi extensions. This package has two faces:
+Shared utilities for Pi extensions that need coordinated UI, fullscreen overlays, reminders, and logging.
 
-- `index.ts` is the Pi host extension registered through `package.json` `pi.extensions`.
-- `src/index.ts` is the client library surface that other extensions can vendor and import.
+Two faces:
 
-## Architecture
+- **Host extension** — `package.json` loads `./dist/index.js` once per Pi session.
+- **Client library** — other extensions import from `pi-extension-utils`.
 
-The host and clients communicate over Pi's shared in-process `pi.events` bus. Protocol events are namespaced as `pi-extension-utils:*` and every payload carries `protocolVersion` and `clientId`. Payloads may carry live function references because they never leave the process.
+## Quick Start
 
-Clients emit `hello` and listen for `ready`. Before a host is ready, widget calls fall back to the consumer extension's own `ctx.ui.setWidget`. If a host arrives later, fallback widgets are cleared and re-registered through the coordinator.
+```bash
+npm install pi-extension-utils
+```
+
+Add the package to Pi settings so the host extension loads:
 
-The host owns one real widget per placement and composes registered sub-widgets sorted by `(order, insertion)`. Fullscreen leases blank coordinated widgets until all leases are released or the owning client disposes.
+```json
+{
+  "packages": ["npm:pi-extension-utils"]
+}
+```
 
-## API sketch
+Use the client from another extension:
 
 ```ts
-import { connect, createLogger } from "pi-extension-utils";
+import { connect } from "pi-extension-utils";
 
 const client = connect(pi, { ctx, clientId: "my-extension" });
-client.widgets.set("belowEditor", "status", (tui, theme) => component, { order: 10 });
-client.widgets.remove("belowEditor", "status");
+```
 
-// Run a custom fullscreen UI: widgets are blanked before mount and
-// restored afterwards, even if the component throws.
-const result = await client.ui.fullscreen<string | null>(
-  (tui, theme, keybindings, done) => new MyOverlayComponent(tui, theme, done),
-);
+## What you get
 
-// Lower-level lease, for manual control over the blank/restore window.
-const lease = client.fullscreen.acquire();
-lease.release();
+| Feature | Use when |
+|---|---|
+| Widget coordinator | Multiple extensions need ordered widgets above/below the editor |
+| `ui.fullscreen()` | A command opens a custom full-screen UI and should hide widgets while open |
+| `paneOverlay()` | You want a master/detail fullscreen dashboard with built-in keys and legend |
+| Reminders | An extension needs durable model-visible guidance without mutating prompts |
+| Logger | You need namespaced rotating logs |
 
-// Reminders (host absorbed from pi-reminders): fire-and-forget emits;
-// list() resolves { reminders: [], count: 0 } when no host is present.
-client.reminders.upsert({ id: "my-reminder", text: "...", source: "my-extension" });
-client.reminders.remove("my-reminder");
-client.reminders.clearSource("my-extension");
-const { reminders } = await client.reminders.list();
+## Small Example
 
-client.dispose();
+```ts
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { connect, createLogger, paneOverlay } from "pi-extension-utils";
 
 const log = createLogger("my-extension");
-log.info("started");
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", (_event, ctx) => {
+    const client = connect(pi, { ctx, clientId: "my-extension" });
+
+    client.widgets.set("belowEditor", "status", () => ({
+      render: () => ["my-extension: ready"],
+      invalidate: () => {},
+    }), { order: 10 });
+
+    client.reminders.upsert({
+      source: "my-extension",
+      id: "state",
+      text: "Remember the current extension state.",
+    });
+  });
+
+  pi.registerCommand("my-dashboard", {
+    description: "Open my extension dashboard",
+    handler: async (_args, ctx) => {
+      const client = connect(pi, { ctx, clientId: "my-extension" });
+      await client.ui.fullscreen(paneOverlay({
+        primary: { title: "Items", mode: "cursor", rows: ["alpha", "beta"] },
+        detail: { title: "Details", rows: (o) => [`selected: ${o.selectedRow}`] },
+      }));
+    },
+  });
+
+  log.info("registered");
+}
+```
+
+## Docs
+
+| Topic | Link |
+|---|---|
+| Client APIs | [docs/client.md](docs/client.md) |
+| Config files | [docs/config.md](docs/config.md) |
+| Widget coordinator | [docs/widgets.md](docs/widgets.md) |
+| Pane overlays | [docs/pane-overlay.md](docs/pane-overlay.md) |
+| Reminders | [docs/reminders.md](docs/reminders.md) |
+
+## Examples
+
+See [examples/](examples/).
+
+| Example | Shows |
+|---|---|
+| [`widget-coordinator.ts`](examples/widget-coordinator.ts) | Ordered widgets through the coordinator |
+| [`config.ts`](examples/config.ts) | Extension-owned JSON/JSONC config |
+| [`pane-overlay.ts`](examples/pane-overlay.ts) | Fullscreen master/detail dashboard |
+| [`reminders.ts`](examples/reminders.ts) | Upsert/list/clear reminders |
+| [`logger.ts`](examples/logger.ts) | Namespaced logger |
+
+## Development
+
+```bash
+npm run typecheck
+npm test
+npm run build
 ```

package/dist/index.js

@@ -1,145 +1,14 @@
-import { registerReminderHost } from "./src/reminders/index.js";
-import { basePayload, EVENTS, PROTOCOL_VERSION, } from "./src/protocol.js";
-const HOST_CLIENT_ID = "pi-extension-utils-host";
-const HOST_WIDGET_PREFIX = "pi-extension-utils";
-const PLACEMENTS = ["aboveEditor", "belowEditor"];
+import { registerReminderHost } from "./src/reminders/host.js";
+import { registerWidgetHost } from "./src/widgets/host.js";
 export default function (pi) {
-    registerReminderHost(pi);
-    const widgets = new Map();
-    const fullscreenStack = [];
-    let seq = 0;
-    let currentCtx;
-    for (const placement of PLACEMENTS)
-        widgets.set(placement, []);
-    function setHostWidget(placement) {
-        if (!currentCtx)
-            return;
-        const records = sortedWidgets(placement);
-        const hidden = fullscreenStack.length > 0;
-        if (records.length === 0 && !hidden) {
-            currentCtx.ui.setWidget(hostKey(placement), undefined, { placement });
-            return;
-        }
-        currentCtx.ui.setWidget(hostKey(placement), (tui, theme) => createHostComponent(tui, theme, records, hidden), { placement });
-    }
-    function rerenderAll() {
-        for (const placement of PLACEMENTS)
-            setHostWidget(placement);
-    }
-    pi.events.on(EVENTS.hello, (data) => {
-        const payload = readPayload(data, "hello");
-        if (!payload)
-            return;
-        pi.events.emit(EVENTS.ready, basePayload(HOST_CLIENT_ID));
-    });
-    pi.events.on(EVENTS.registerWidget, (data) => {
-        const payload = readPayload(data, "register-widget");
-        if (!payload || !isPlacement(payload.placement) || typeof payload.key !== "string" || typeof payload.order !== "number" || typeof payload.factory !== "function") {
-            warnDrop("register-widget", data);
-            return;
-        }
-        const records = widgets.get(payload.placement);
-        const existing = records.find((record) => record.clientId === payload.clientId && record.key === payload.key);
-        if (existing) {
-            existing.order = payload.order;
-            existing.factory = payload.factory;
-        }
-        else {
-            records.push({ clientId: payload.clientId, key: payload.key, order: payload.order, factory: payload.factory, seq: seq++ });
-        }
-        setHostWidget(payload.placement);
-    });
-    pi.events.on(EVENTS.unregisterWidget, (data) => {
-        const payload = readPayload(data, "unregister-widget");
-        if (!payload)
-            return;
-        if (payload.all) {
-            removeClient(payload.clientId);
-            rerenderAll();
-            return;
-        }
-        if (!isPlacement(payload.placement) || typeof payload.key !== "string") {
-            warnDrop("unregister-widget", data);
-            return;
-        }
-        const records = widgets.get(payload.placement);
-        widgets.set(payload.placement, records.filter((record) => record.clientId !== payload.clientId || record.key !== payload.key));
-        setHostWidget(payload.placement);
-    });
-    pi.events.on(EVENTS.fullscreenAcquire, (data) => {
-        const payload = readPayload(data, "fullscreen-acquire");
-        if (!payload || typeof payload.token !== "string") {
-            warnDrop("fullscreen-acquire", data);
-            return;
-        }
-        if (!fullscreenStack.some((lease) => lease.token === payload.token)) {
-            fullscreenStack.push({ clientId: payload.clientId, token: payload.token });
-            rerenderAll();
-        }
-    });
-    pi.events.on(EVENTS.fullscreenRelease, (data) => {
-        const payload = readPayload(data, "fullscreen-release");
-        if (!payload || typeof payload.token !== "string") {
-            warnDrop("fullscreen-release", data);
-            return;
-        }
-        const before = fullscreenStack.length;
-        for (let index = fullscreenStack.length - 1; index >= 0; index--) {
-            if (fullscreenStack[index].token === payload.token)
-                fullscreenStack.splice(index, 1);
-        }
-        if (fullscreenStack.length !== before)
-            rerenderAll();
-    });
-    pi.on("session_start", (_event, ctx) => {
-        currentCtx = ctx;
-        rerenderAll();
-        pi.events.emit(EVENTS.ready, basePayload(HOST_CLIENT_ID));
-    });
-    pi.events.emit(EVENTS.ready, basePayload(HOST_CLIENT_ID));
-    function removeClient(clientId) {
-        for (const placement of PLACEMENTS) {
-            widgets.set(placement, widgets.get(placement).filter((record) => record.clientId !== clientId));
-        }
-        for (let index = fullscreenStack.length - 1; index >= 0; index--) {
-            if (fullscreenStack[index].clientId === clientId)
-                fullscreenStack.splice(index, 1);
-        }
-    }
-    function sortedWidgets(placement) {
-        return [...widgets.get(placement)].sort((a, b) => a.order - b.order || a.seq - b.seq);
-    }
+    registerHost("reminders", () => registerReminderHost(pi));
+    registerHost("widgets", () => registerWidgetHost(pi));
 }
-function createHostComponent(tui, theme, records, hidden) {
-    const components = hidden ? [] : records.map((record) => record.factory(tui, theme));
-    return {
-        render(width) {
-            return components.flatMap((component) => component.render(width));
-        },
-        invalidate() {
-            for (const component of components)
-                component.invalidate();
-        },
-    };
-}
-function hostKey(placement) {
-    return `${HOST_WIDGET_PREFIX}-${placement}`;
-}
-function readPayload(data, eventName) {
-    if (!data || typeof data !== "object") {
-        warnDrop(eventName, data);
-        return undefined;
+function registerHost(name, register) {
+    try {
+        register();
     }
-    const payload = data;
-    if (typeof payload.protocolVersion !== "number" || payload.protocolVersion > PROTOCOL_VERSION || typeof payload.clientId !== "string") {
-        warnDrop(eventName, data);
-        return undefined;
+    catch (error) {
+        console.warn(`pi-extension-utils: failed to register ${name} host`, error);
     }
-    return payload;
-}
-function isPlacement(value) {
-    return value === "aboveEditor" || value === "belowEditor";
-}
-function warnDrop(eventName, data) {
-    console.warn(`pi-extension-utils: dropping invalid ${eventName} payload`, data);
 }

package/dist/src/client/index.d.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { UtilsClient, UtilsClientOptions } from "./types.ts";
+export type { UtilsClient, UtilsClientOptions } from "./types.ts";
+export type { RemindersClient } from "../reminders/client.ts";
+export type { FullscreenComponentFactory, UiClient } from "../ui/client.ts";
+export type { FullscreenClient, FullscreenLease, WidgetsClient, WidgetSetOptions } from "../widgets/client.ts";
+export declare function connect(pi: ExtensionAPI, opts: UtilsClientOptions): UtilsClient;

package/dist/src/client/index.js

@@ -0,0 +1,25 @@
+import { createRemindersClient } from "../reminders/client.js";
+import { createUiClient } from "../ui/client.js";
+import { connectWidgetCoordinator } from "../widgets/client.js";
+let nextClientId = 1;
+export function connect(pi, opts) {
+    const clientId = opts.clientId ?? `client-${process.pid}-${Date.now()}-${nextClientId++}`;
+    let disposed = false;
+    const coordinator = connectWidgetCoordinator(pi, { ctx: opts.ctx, clientId });
+    return {
+        clientId,
+        get mode() {
+            return coordinator.mode;
+        },
+        widgets: coordinator.widgets,
+        fullscreen: coordinator.fullscreen,
+        ui: createUiClient(coordinator.fullscreen, opts.ctx),
+        reminders: createRemindersClient(pi, () => disposed),
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            coordinator.dispose();
+        },
+    };
+}

package/dist/src/client/types.d.ts

@@ -0,0 +1,17 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { RemindersClient } from "../reminders/client.ts";
+import type { UiClient } from "../ui/client.ts";
+import type { FullscreenClient, WidgetsClient } from "../widgets/client.ts";
+export interface UtilsClientOptions {
+    ctx: ExtensionContext;
+    clientId?: string;
+}
+export interface UtilsClient {
+    readonly clientId: string;
+    readonly mode: "fallback" | "coordinated";
+    widgets: WidgetsClient;
+    fullscreen: FullscreenClient;
+    ui: UiClient;
+    reminders: RemindersClient;
+    dispose(): void;
+}

package/dist/src/client/types.js

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

package/dist/src/config/index.d.ts

@@ -0,0 +1,28 @@
+import type { Static, TSchema } from "typebox";
+export type ConfigFormat = "json" | "jsonc";
+export type DeepPartial<T> = T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export interface DefineConfigOptions<Schema extends TSchema> {
+    /** File basename, without .json/.jsonc. */
+    name: string;
+    /** Directory containing <name>.json or <name>.jsonc. Defaults to getAgentDir()/config. */
+    dir?: string;
+    /** TypeBox schema. Field defaults and descriptions are read from this schema. */
+    schema: Schema;
+}
+export interface DefinedConfig<Schema extends TSchema> {
+    readonly name: string;
+    readonly schema: Schema;
+    /** Return the resolved config path. If missing, returns the default .jsonc path. */
+    path(): string;
+    /** Ensure the config file exists, creating .jsonc with schema defaults/comments when missing. */
+    ensure(): string;
+    /** Ensure, load, apply schema defaults, validate, cache, and return config. */
+    get(): Static<Schema>;
+    /** Force a disk reread, replacing the cached value. */
+    reload(): Static<Schema>;
+    /** Patch config or mutate a draft; writes to disk and updates cache. */
+    update(patch: DeepPartial<Static<Schema>> | ((draft: Static<Schema>) => void)): Static<Schema>;
+}
+export declare function defineConfig<Schema extends TSchema>(options: DefineConfigOptions<Schema>): DefinedConfig<Schema>;

package/dist/src/config/index.js

@@ -0,0 +1,222 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { applyEdits, modify, parse as parseJsonc, printParseErrorCode } from "jsonc-parser";
+import { Value } from "typebox/value";
+const FORMAT_OPTIONS = { insertSpaces: false, tabSize: 1, eol: "\n", insertFinalNewline: true };
+export function defineConfig(options) {
+    validateName(options.name);
+    let cachedPath;
+    let cachedValue;
+    const config = {
+        name: options.name,
+        schema: options.schema,
+        path() {
+            return resolvePath().path;
+        },
+        ensure() {
+            const resolved = resolvePath();
+            if (!resolved.exists) {
+                mkdirSync(configDir(), { recursive: true });
+                writeFileSync(resolved.path, createInitialContent(options.schema, resolved.format));
+                cachedPath = { ...resolved, exists: true };
+            }
+            return resolved.path;
+        },
+        get() {
+            if (cachedValue !== undefined)
+                return cloneJson(cachedValue);
+            return load(true);
+        },
+        reload() {
+            cachedValue = undefined;
+            cachedPath = undefined;
+            return load(true);
+        },
+        update(patch) {
+            const filePath = config.ensure();
+            const resolved = resolvePath();
+            const before = load(false);
+            const draft = cloneJson(before);
+            if (typeof patch === "function") {
+                patch(draft);
+            }
+            else {
+                mergeDeep(draft, patch);
+            }
+            const after = applyDefaultsAndValidate(options.schema, draft, resolved.path);
+            writeUpdatedConfig(filePath, resolved.format, before, after);
+            cachedValue = cloneJson(after);
+            return cloneJson(after);
+        },
+    };
+    function configDir() {
+        return options.dir ?? join(getAgentDir(), "config");
+    }
+    function resolvePath() {
+        if (cachedPath?.exists)
+            return cachedPath;
+        const dir = configDir();
+        const jsoncPath = join(dir, `${options.name}.jsonc`);
+        const jsonPath = join(dir, `${options.name}.json`);
+        const hasJsonc = existsSync(jsoncPath);
+        const hasJson = existsSync(jsonPath);
+        if (hasJsonc && hasJson) {
+            throw new Error(`Config '${options.name}' is ambiguous: both ${jsoncPath} and ${jsonPath} exist`);
+        }
+        cachedPath = hasJsonc
+            ? { path: jsoncPath, format: "jsonc", exists: true }
+            : hasJson
+                ? { path: jsonPath, format: "json", exists: true }
+                : { path: jsoncPath, format: "jsonc", exists: false };
+        return cachedPath;
+    }
+    function load(ensure) {
+        if (ensure)
+            config.ensure();
+        const resolved = resolvePath();
+        let parsed = {};
+        if (resolved.exists || existsSync(resolved.path)) {
+            parsed = readConfigFile(resolved.path, resolved.format);
+        }
+        const value = applyDefaultsAndValidate(options.schema, parsed, resolved.path);
+        cachedValue = cloneJson(value);
+        return cloneJson(value);
+    }
+    return config;
+}
+function validateName(name) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+        throw new Error(`Config name must be a filename base using letters, numbers, '.', '_' or '-': ${name}`);
+    }
+}
+function readConfigFile(path, format) {
+    const text = readFileSync(path, "utf8");
+    if (!text.trim())
+        return {};
+    if (format === "json")
+        return JSON.parse(text);
+    const errors = [];
+    const parsed = parseJsonc(text, errors, { allowTrailingComma: true });
+    if (errors.length > 0) {
+        const first = errors[0];
+        throw new Error(`Invalid JSONC in ${path} at offset ${first.offset}: ${printParseErrorCode(first.error)}`);
+    }
+    return parsed ?? {};
+}
+function applyDefaultsAndValidate(schema, value, path) {
+    const defaults = defaultValue(schema);
+    const merged = mergeDefaults(defaults.hasDefault ? defaults.value : {}, isPlainObject(value) ? value : value ?? {});
+    Value.Default(schema, merged);
+    if (!Value.Check(schema, merged)) {
+        const details = [...Value.Errors(schema, merged)]
+            .slice(0, 5)
+            .map((error) => `${"path" in error && typeof error.path === "string" ? error.path : "/"} ${error.message}`)
+            .join("; ");
+        throw new Error(`Invalid config ${path}: ${details}`);
+    }
+    return merged;
+}
+function writeUpdatedConfig(path, format, before, after) {
+    if (format === "json") {
+        writeFileSync(path, `${JSON.stringify(after, null, "\t")}\n`);
+        return;
+    }
+    let text = readFileSync(path, "utf8");
+    for (const diff of diffLeaves(before, after)) {
+        const edits = modify(text, diff.path, diff.value, { formattingOptions: FORMAT_OPTIONS });
+        text = applyEdits(text, edits);
+    }
+    writeFileSync(path, text.endsWith("\n") ? text : `${text}\n`);
+}
+function createInitialContent(schema, format) {
+    const typedSchema = schema;
+    const defaults = defaultValue(typedSchema);
+    const value = defaults.hasDefault ? defaults.value : typedSchema.type === "object" ? {} : null;
+    if (format === "json")
+        return `${JSON.stringify(value, null, "\t")}\n`;
+    return `${stringifyJsoncWithComments(value, typedSchema, 0)}\n`;
+}
+function stringifyJsoncWithComments(value, schema, level) {
+    if (isPlainObject(value)) {
+        const properties = isPlainObject(schema.properties) ? schema.properties : {};
+        const keys = orderedKeys(value, properties);
+        if (keys.length === 0)
+            return "{}";
+        const lines = ["{"];
+        keys.forEach((key, index) => {
+            const childSchema = properties[key] ?? {};
+            const indent = "\t".repeat(level + 1);
+            const description = typeof childSchema.description === "string" ? childSchema.description.trim() : "";
+            if (description) {
+                for (const line of description.split(/\r?\n/)) {
+                    lines.push(`${indent}// ${line.trim()}`);
+                }
+            }
+            const rendered = stringifyJsoncWithComments(value[key], childSchema, level + 1);
+            lines.push(`${indent}${JSON.stringify(key)}: ${rendered}${index === keys.length - 1 ? "" : ","}`);
+        });
+        lines.push(`${"\t".repeat(level)}}`);
+        return lines.join("\n");
+    }
+    return JSON.stringify(value, null, "\t");
+}
+function orderedKeys(value, properties) {
+    const object = value;
+    const keys = new Set([...Object.keys(properties), ...Object.keys(object)]);
+    return [...keys].filter((key) => Object.prototype.hasOwnProperty.call(object, key));
+}
+function defaultValue(schema) {
+    if (Object.prototype.hasOwnProperty.call(schema, "default")) {
+        return { hasDefault: true, value: cloneJson(schema.default) };
+    }
+    if (schema.type === "object" && isPlainObject(schema.properties)) {
+        const value = {};
+        for (const [key, child] of Object.entries(schema.properties)) {
+            const childDefault = defaultValue(child);
+            if (childDefault.hasDefault)
+                value[key] = childDefault.value;
+        }
+        return Object.keys(value).length > 0 ? { hasDefault: true, value } : { hasDefault: false, value: undefined };
+    }
+    return { hasDefault: false, value: undefined };
+}
+function mergeDefaults(defaults, value) {
+    if (isPlainObject(defaults) && isPlainObject(value)) {
+        const merged = { ...cloneJson(defaults) };
+        for (const [key, childValue] of Object.entries(value)) {
+            merged[key] = Object.prototype.hasOwnProperty.call(merged, key)
+                ? mergeDefaults(merged[key], childValue)
+                : childValue;
+        }
+        return merged;
+    }
+    return value === undefined ? cloneJson(defaults) : value;
+}
+function mergeDeep(target, patch) {
+    if (!isPlainObject(target) || !isPlainObject(patch))
+        return;
+    for (const [key, value] of Object.entries(patch)) {
+        if (isPlainObject(value) && isPlainObject(target[key])) {
+            mergeDeep(target[key], value);
+        }
+        else {
+            target[key] = cloneJson(value);
+        }
+    }
+}
+function diffLeaves(before, after, path = []) {
+    if (isPlainObject(before) && isPlainObject(after)) {
+        const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+        return [...keys].flatMap((key) => diffLeaves(before[key], after[key], [...path, key]));
+    }
+    if (JSON.stringify(before) === JSON.stringify(after))
+        return [];
+    return [{ path, value: after }];
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneJson(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}

package/dist/src/index.d.ts

@@ -1,7 +1,11 @@
-export { connect, type FullscreenLease, type RemindersClient, type UtilsClient, type UtilsClientOptions, type WidgetSetOptions } from "./client.ts";
-export { createLogger, type Logger, type LoggerOptions } from "./logger.ts";
-export * from "./key-dispatch.ts";
-export * from "./pane-state.ts";
-export * from "./protocol.ts";
+export { connect, type FullscreenComponentFactory, type FullscreenLease, type RemindersClient, type UtilsClient, type UtilsClientOptions, type WidgetSetOptions } from "./client/index.ts";
+export { defineConfig, type DeepPartial, type DefinedConfig, type DefineConfigOptions } from "./config/index.ts";
+export { createLogger, LOG_LEVELS, loggerLevelSchema, loggingConfigSchema, type Logger, type LoggerLevel, type LoggerOptions, type LoggingConfig, type LogLevel } from "./logger/index.ts";
+export { utilsConfigSchema, type UtilsConfig } from "./utils-config.ts";
+export * from "./pane/key-dispatch.ts";
+export * from "./pane/state.ts";
+export * from "./widgets/protocol.ts";
+export { remindersConfigSchema, type RemindersConfig } from "./reminders/config.ts";
 export * from "./reminders/types.ts";
-export * from "./tui-chrome.ts";
+export * from "./pane/chrome.ts";
+export * from "./pane/overlay.ts";

package/dist/src/index.js

@@ -1,7 +1,11 @@
-export { connect } from "./client.js";
-export { createLogger } from "./logger.js";
-export * from "./key-dispatch.js";
-export * from "./pane-state.js";
-export * from "./protocol.js";
+export { connect } from "./client/index.js";
+export { defineConfig } from "./config/index.js";
+export { createLogger, LOG_LEVELS, loggerLevelSchema, loggingConfigSchema } from "./logger/index.js";
+export { utilsConfigSchema } from "./utils-config.js";
+export * from "./pane/key-dispatch.js";
+export * from "./pane/state.js";
+export * from "./widgets/protocol.js";
+export { remindersConfigSchema } from "./reminders/config.js";
 export * from "./reminders/types.js";
-export * from "./tui-chrome.js";
+export * from "./pane/chrome.js";
+export * from "./pane/overlay.js";

package/dist/src/logger/config.d.ts

@@ -0,0 +1,11 @@
+import { Type, type Static } from "typebox";
+export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+export type LogLevel = typeof LOG_LEVELS[number];
+export type LoggerLevel = LogLevel | "silent";
+export declare const loggerLevelSchema: Type.TUnion<[Type.TLiteral<"debug">, Type.TLiteral<"info">, Type.TLiteral<"warn">, Type.TLiteral<"error">, Type.TLiteral<"silent">]>;
+export declare const loggingConfigSchema: Type.TObject<{
+    level: Type.TUnion<[Type.TLiteral<"debug">, Type.TLiteral<"info">, Type.TLiteral<"warn">, Type.TLiteral<"error">, Type.TLiteral<"silent">]>;
+    maxFiles: Type.TNumber;
+    maxBytes: Type.TNumber;
+}>;
+export type LoggingConfig = Static<typeof loggingConfigSchema>;