pi-extension-utils 0.3.0 → 0.3.2

package/dist/src/client.d.ts

@@ -1,47 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { WidgetFactory, WidgetPlacement } from "./protocol.ts";
-import { type ReminderAnnounceNowRequest, type ReminderIntent, type ReminderSnapshot } from "./reminders/types.ts";
-export interface UtilsClientOptions {
-    ctx: ExtensionContext;
-    clientId?: string;
-}
-export interface WidgetSetOptions {
-    order?: number;
-}
-export interface FullscreenLease {
-    release(): void;
-}
-/**
- * Factory signature accepted by `ctx.ui.custom`. Typed structurally so the
- * client does not depend on pi-tui types directly.
- */
-export type FullscreenComponentFactory<T> = (tui: unknown, theme: unknown, keybindings: unknown, done: (result: T) => void) => unknown;
-export interface RemindersClient {
-    upsert(intent: ReminderIntent): void;
-    remove(source: string, key: string): void;
-    clearSource(source: string): void;
-    announceNow(payload?: ReminderAnnounceNowRequest): void;
-    list(source?: string): Promise<ReminderSnapshot>;
-}
-export interface UtilsClient {
-    readonly clientId: string;
-    readonly mode: "fallback" | "coordinated";
-    widgets: {
-        set(placement: WidgetPlacement, key: string, factory: WidgetFactory, opts?: WidgetSetOptions): void;
-        remove(placement: WidgetPlacement, key: string): void;
-    };
-    fullscreen: {
-        acquire(): FullscreenLease;
-    };
-    ui: {
-        /**
-         * Run a full-screen custom UI: acquires a fullscreen lease (blanking
-         * coordinated widgets), shows the component via `ctx.ui.custom`, and
-         * releases the lease in a finally — even if the component throws.
-         */
-        fullscreen<T>(factory: FullscreenComponentFactory<T>): Promise<T>;
-    };
-    reminders: RemindersClient;
-    dispose(): void;
-}
-export declare function connect(pi: ExtensionAPI, opts: UtilsClientOptions): UtilsClient;

package/dist/src/client.js

@@ -1,194 +0,0 @@
-import { REMINDER_ANNOUNCE_NOW_EVENT, REMINDER_CLEAR_SOURCE_EVENT, REMINDER_LIST_EVENT, REMINDER_REMOVE_EVENT, REMINDER_UPSERT_EVENT, } from "./reminders/types.js";
-import { basePayload, EVENTS, PROTOCOL_VERSION, } from "./protocol.js";
-let nextClientId = 1;
-let nextLeaseId = 1;
-export function connect(pi, opts) {
-    const clientId = opts.clientId ?? `client-${process.pid}-${Date.now()}-${nextClientId++}`;
-    const widgets = new Map();
-    const leases = new Set();
-    let disposed = false;
-    let coordinated = false;
-    const widgetId = (placement, key) => `${placement}:${key}`;
-    function emitRegister(record) {
-        pi.events.emit(EVENTS.registerWidget, {
-            ...basePayload(clientId),
-            placement: record.placement,
-            key: record.key,
-            order: record.order,
-            factory: record.factory,
-        });
-    }
-    function clearFallback(record) {
-        opts.ctx.ui.setWidget(record.key, undefined, { placement: record.placement });
-    }
-    function restoreFallback(record) {
-        opts.ctx.ui.setWidget(record.key, record.factory, { placement: record.placement });
-    }
-    function attach() {
-        if (disposed || coordinated)
-            return;
-        coordinated = true;
-        for (const record of widgets.values()) {
-            clearFallback(record);
-            emitRegister(record);
-        }
-        for (const token of leases) {
-            pi.events.emit(EVENTS.fullscreenAcquire, { ...basePayload(clientId), token });
-        }
-    }
-    const offReady = pi.events.on(EVENTS.ready, (data) => {
-        if (!isReadyPayload(data))
-            return;
-        attach();
-    });
-    pi.events.emit(EVENTS.hello, basePayload(clientId));
-    const client = {
-        clientId,
-        get mode() {
-            return coordinated ? "coordinated" : "fallback";
-        },
-        widgets: {
-            set(placement, key, factory, setOpts = {}) {
-                if (disposed)
-                    return;
-                const record = { placement, key, factory, order: setOpts.order ?? 0 };
-                widgets.set(widgetId(placement, key), record);
-                if (coordinated) {
-                    emitRegister(record);
-                }
-                else if (leases.size === 0) {
-                    opts.ctx.ui.setWidget(key, factory, { placement });
-                }
-            },
-            remove(placement, key) {
-                const id = widgetId(placement, key);
-                const record = widgets.get(id);
-                if (!record)
-                    return;
-                widgets.delete(id);
-                if (coordinated) {
-                    pi.events.emit(EVENTS.unregisterWidget, { ...basePayload(clientId), placement, key });
-                }
-                else {
-                    clearFallback(record);
-                }
-            },
-        },
-        fullscreen: {
-            acquire() {
-                const token = `${clientId}-lease-${nextLeaseId++}`;
-                let released = false;
-                const wasFallbackVisible = !coordinated && leases.size === 0;
-                leases.add(token);
-                if (coordinated) {
-                    pi.events.emit(EVENTS.fullscreenAcquire, { ...basePayload(clientId), token });
-                }
-                else if (wasFallbackVisible) {
-                    for (const record of widgets.values())
-                        clearFallback(record);
-                }
-                return {
-                    release() {
-                        if (released)
-                            return;
-                        released = true;
-                        leases.delete(token);
-                        if (coordinated && !disposed) {
-                            pi.events.emit(EVENTS.fullscreenRelease, { ...basePayload(clientId), token });
-                        }
-                        else if (!disposed && leases.size === 0) {
-                            for (const record of widgets.values())
-                                restoreFallback(record);
-                        }
-                    },
-                };
-            },
-        },
-        ui: {
-            async fullscreen(factory) {
-                const ui = opts.ctx.ui;
-                if (typeof ui.custom !== "function") {
-                    throw new Error("pi-extension-utils: ui.fullscreen requires an interactive UI (ctx.ui.custom is unavailable)");
-                }
-                const lease = client.fullscreen.acquire();
-                try {
-                    return await ui.custom(factory);
-                }
-                finally {
-                    lease.release();
-                }
-            },
-        },
-        reminders: {
-            upsert(intent) {
-                if (disposed)
-                    return;
-                pi.events.emit(REMINDER_UPSERT_EVENT, intent);
-            },
-            remove(source, key) {
-                if (disposed)
-                    return;
-                pi.events.emit(REMINDER_REMOVE_EVENT, { source, id: key });
-            },
-            clearSource(source) {
-                if (disposed)
-                    return;
-                pi.events.emit(REMINDER_CLEAR_SOURCE_EVENT, { source });
-            },
-            announceNow(payload = {}) {
-                if (disposed)
-                    return;
-                pi.events.emit(REMINDER_ANNOUNCE_NOW_EVENT, payload);
-            },
-            list(source) {
-                if (disposed)
-                    return Promise.resolve(emptyReminderSnapshot());
-                let settled = false;
-                let resolveSnapshot;
-                let rejectSnapshot;
-                const promise = new Promise((resolve, reject) => {
-                    resolveSnapshot = (snapshot) => {
-                        settled = true;
-                        resolve(snapshot);
-                    };
-                    rejectSnapshot = (error) => {
-                        settled = true;
-                        reject(error);
-                    };
-                });
-                pi.events.emit(REMINDER_LIST_EVENT, { source, resolve: resolveSnapshot, reject: rejectSnapshot });
-                if (!settled)
-                    resolveSnapshot(emptyReminderSnapshot());
-                return promise;
-            },
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            offReady();
-            if (coordinated) {
-                pi.events.emit(EVENTS.unregisterWidget, { ...basePayload(clientId), all: true });
-                for (const token of leases) {
-                    pi.events.emit(EVENTS.fullscreenRelease, { ...basePayload(clientId), token });
-                }
-            }
-            else {
-                for (const record of widgets.values())
-                    clearFallback(record);
-            }
-            leases.clear();
-            widgets.clear();
-        },
-    };
-    return client;
-}
-function isReadyPayload(data) {
-    if (!data || typeof data !== "object")
-        return false;
-    const payload = data;
-    return typeof payload.protocolVersion === "number" && payload.protocolVersion <= PROTOCOL_VERSION && typeof payload.clientId === "string";
-}
-function emptyReminderSnapshot() {
-    return { reminders: [], count: 0 };
-}

package/dist/src/logger.d.ts

@@ -1,12 +0,0 @@
-export interface LoggerOptions {
-    dir?: string;
-    maxBytes?: number;
-}
-export interface Logger {
-    debug(message: string): void;
-    info(message: string): void;
-    warn(message: string): void;
-    error(message: string): void;
-    log(level: string, message: string): void;
-}
-export declare function createLogger(ns: string, opts?: LoggerOptions): Logger;

package/dist/src/logger.js

@@ -1,45 +0,0 @@
-import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-const DEFAULT_MAX_BYTES = 1024 * 1024;
-export function createLogger(ns, opts = {}) {
-    if (!ns || ns.includes("/") || ns.includes("\\")) {
-        throw new Error("Logger namespace must not contain path separators");
-    }
-    const dir = opts.dir ?? join(homedir(), ".pi", "logs");
-    const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
-    const file = join(dir, `${ns}.log`);
-    mkdirSync(dirname(file), { recursive: true });
-    function rotateIfNeeded(nextBytes) {
-        if (maxBytes <= 0 || !existsSync(file))
-            return;
-        const size = statSync(file).size;
-        if (size + nextBytes <= maxBytes)
-            return;
-        const rotated = `${file}.1`;
-        if (existsSync(rotated))
-            rmSync(rotated);
-        renameSync(file, rotated);
-    }
-    function log(level, message) {
-        const line = `${new Date().toISOString()} ${level} ${message}\n`;
-        mkdirSync(dirname(file), { recursive: true });
-        rotateIfNeeded(Buffer.byteLength(line));
-        appendFileSync(file, line);
-    }
-    return {
-        debug(message) {
-            log("debug", message);
-        },
-        info(message) {
-            log("info", message);
-        },
-        warn(message) {
-            log("warn", message);
-        },
-        error(message) {
-            log("error", message);
-        },
-        log,
-    };
-}