pi-extension-utils 0.3.1 → 0.3.2

package/dist/src/logger/config.js

@@ -0,0 +1,27 @@
+import { Type } from "typebox";
+export const LOG_LEVELS = ["debug", "info", "warn", "error"];
+export const loggerLevelSchema = Type.Union([
+    Type.Literal("debug"),
+    Type.Literal("info"),
+    Type.Literal("warn"),
+    Type.Literal("error"),
+    Type.Literal("silent"),
+], {
+    default: "info",
+    description: "Minimum log level to write.",
+});
+export const loggingConfigSchema = Type.Object({
+    level: loggerLevelSchema,
+    maxFiles: Type.Number({
+        default: 3,
+        minimum: 0,
+        description: "Number of rotated log files to retain.",
+    }),
+    maxBytes: Type.Number({
+        default: 1048576,
+        minimum: 0,
+        description: "Rotate a log file when it grows beyond this many bytes. Use 0 to disable rotation.",
+    }),
+}, {
+    description: "Default logger settings used when createLogger() options omit a value.",
+});

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

@@ -0,0 +1,20 @@
+import { type LoggerLevel, type LogLevel } from "./config.ts";
+export { LOG_LEVELS, loggerLevelSchema, loggingConfigSchema, type LoggerLevel, type LoggingConfig, type LogLevel } from "./config.ts";
+export interface LoggerOptions {
+    dir?: string;
+    maxBytes?: number;
+    /** Number of rotated files to retain: name.log.1, name.log.2, ... */
+    maxFiles?: number;
+    /** Minimum level to write. Defaults to utilsConfig.logging.level. */
+    level?: LoggerLevel;
+}
+export interface Logger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    log(level: LogLevel, message: string): void;
+    setLevel(level: LoggerLevel): void;
+    isEnabled(level: LogLevel): boolean;
+}
+export declare function createLogger(name: string, opts?: LoggerOptions): Logger;

package/dist/src/logger/index.js

@@ -0,0 +1,76 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readUtilsConfigOrDefaults } from "../utils-config.js";
+export { LOG_LEVELS, loggerLevelSchema, loggingConfigSchema } from "./config.js";
+const LEVEL_WEIGHT = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    silent: Number.POSITIVE_INFINITY,
+};
+export function createLogger(name, opts = {}) {
+    if (!name || name.includes("/") || name.includes("\\")) {
+        throw new Error("Logger name must not contain path separators");
+    }
+    const configured = opts.level === undefined || opts.maxBytes === undefined || opts.maxFiles === undefined
+        ? readUtilsConfigOrDefaults().logging
+        : undefined;
+    const dir = opts.dir ?? join(getAgentDir(), "log");
+    const maxBytes = Math.max(0, Math.floor(opts.maxBytes ?? configured?.maxBytes ?? 1024 * 1024));
+    const maxFiles = Math.max(0, Math.floor(opts.maxFiles ?? configured?.maxFiles ?? 3));
+    let level = opts.level ?? configured?.level ?? "info";
+    const file = join(dir, `${name}.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;
+        if (maxFiles <= 0) {
+            rmSync(file);
+            return;
+        }
+        const oldest = `${file}.${maxFiles}`;
+        if (existsSync(oldest))
+            rmSync(oldest);
+        for (let index = maxFiles - 1; index >= 1; index--) {
+            const from = `${file}.${index}`;
+            if (existsSync(from))
+                renameSync(from, `${file}.${index + 1}`);
+        }
+        renameSync(file, `${file}.1`);
+    }
+    function isEnabled(candidate) {
+        return LEVEL_WEIGHT[candidate] >= LEVEL_WEIGHT[level];
+    }
+    function log(candidate, message) {
+        if (!isEnabled(candidate))
+            return;
+        const line = `${new Date().toISOString()} ${candidate} ${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,
+        setLevel(nextLevel) {
+            level = nextLevel;
+        },
+        isEnabled,
+    };
+}

package/dist/src/{pane-overlay.d.ts → pane/overlay.d.ts}

@@ -1,4 +1,4 @@
-import type { FullscreenComponentFactory } from "./client.ts";
+import type { FullscreenComponentFactory } from "../ui/client.ts";
 export interface PaneOverlayContext<T = unknown, Row = unknown> {
     tui: unknown;
     primaryFocus: boolean;

package/dist/src/{pane-overlay.js → pane/overlay.js}

@@ -1,6 +1,6 @@
 import { dispatchNavKeys } from "./key-dispatch.js";
-import { computeFixedSidebarLayout, computeSplitPaneLayout, endCursor, endScrollOffset, ensureCursorVisible, homeCursor, homeScrollOffset, moveCursor, moveScrollOffset, pageCursor, pageScrollOffset, resizeSplitPane, } from "./pane-state.js";
-import { boxRow, clipStyled, flatRule, formatScrollInfo, padRight, renderKeyRow, titledBottomSegment, titledTopSegment, } from "./tui-chrome.js";
+import { computeFixedSidebarLayout, computeSplitPaneLayout, endCursor, endScrollOffset, ensureCursorVisible, homeCursor, homeScrollOffset, moveCursor, moveScrollOffset, pageCursor, pageScrollOffset, resizeSplitPane, } from "./state.js";
+import { boxRow, clipStyled, flatRule, formatScrollInfo, padRight, renderKeyRow, titledBottomSegment, titledTopSegment, } from "./chrome.js";
 import { matchesKey } from "@earendil-works/pi-tui";
 const DEFAULT_CLOSE_KEYS = ["escape", "ctrl+c", "q"];
 function resolveValue(value, ctx) {

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

@@ -0,0 +1,10 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ReminderAnnounceNowRequest, type ReminderIntent, type ReminderSnapshot } from "./types.ts";
+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 declare function createRemindersClient(pi: ExtensionAPI, isDisposed: () => boolean): RemindersClient;

package/dist/src/reminders/client.js

@@ -0,0 +1,49 @@
+import { REMINDER_ANNOUNCE_NOW_EVENT, REMINDER_CLEAR_SOURCE_EVENT, REMINDER_LIST_EVENT, REMINDER_REMOVE_EVENT, REMINDER_UPSERT_EVENT, } from "./types.js";
+export function createRemindersClient(pi, isDisposed) {
+    return {
+        upsert(intent) {
+            if (isDisposed())
+                return;
+            pi.events.emit(REMINDER_UPSERT_EVENT, intent);
+        },
+        remove(source, key) {
+            if (isDisposed())
+                return;
+            pi.events.emit(REMINDER_REMOVE_EVENT, { source, id: key });
+        },
+        clearSource(source) {
+            if (isDisposed())
+                return;
+            pi.events.emit(REMINDER_CLEAR_SOURCE_EVENT, { source });
+        },
+        announceNow(payload = {}) {
+            if (isDisposed())
+                return;
+            pi.events.emit(REMINDER_ANNOUNCE_NOW_EVENT, payload);
+        },
+        list(source) {
+            if (isDisposed())
+                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;
+        },
+    };
+}
+function emptyReminderSnapshot() {
+    return { reminders: [], count: 0 };
+}

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

@@ -1,6 +1,5 @@
-export interface RemindersConfig {
-    debugShowAllInTui?: boolean;
-}
-export declare function configPath(cwd: string): string;
-export declare function loadConfig(cwd: string): RemindersConfig;
-export declare function saveConfig(config: RemindersConfig, cwd: string): void;
+import { Type, type Static } from "typebox";
+export declare const remindersConfigSchema: Type.TObject<{
+    debugShowAllInTui: Type.TBoolean;
+}>;
+export type RemindersConfig = Static<typeof remindersConfigSchema>;

package/dist/src/reminders/config.js

@@ -1,23 +1,9 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-export function configPath(cwd) {
-    return join(cwd, ".pi", "reminders", "reminders-config.json");
-}
-export function loadConfig(cwd) {
-    try {
-        const parsed = JSON.parse(readFileSync(configPath(cwd), "utf8"));
-        if (!parsed || typeof parsed !== "object")
-            return {};
-        return {
-            debugShowAllInTui: typeof parsed.debugShowAllInTui === "boolean" ? parsed.debugShowAllInTui : undefined,
-        };
-    }
-    catch {
-        return {};
-    }
-}
-export function saveConfig(config, cwd) {
-    const filePath = configPath(cwd);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, JSON.stringify(config, null, 2));
-}
+import { Type } from "typebox";
+export const remindersConfigSchema = Type.Object({
+    debugShowAllInTui: Type.Boolean({
+        default: false,
+        description: "Show reminders with display:false in the transcript UI for debugging.",
+    }),
+}, {
+    description: "Reminder host settings.",
+});

package/dist/src/reminders/debug.js

@@ -1,9 +1,9 @@
 import { createHash } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { deriveLabel } from "./renderer.js";
-const DEBUG_LOG_PATH = join(homedir(), ".pi", "log", "reminders.jsonl");
+const DEBUG_LOG_PATH = join(getAgentDir(), "log", "reminders.jsonl");
 export function buildReminderCacheDiagnostics(input) {
     const before = getProviderMessages(input.payload);
     const after = getProviderMessages(input.resultPayload);

package/dist/src/reminders/host.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { ReminderManager } from "./manager.ts";
+/** Register the shared reminder host hooks and event listeners. */
+export declare function registerReminderHost(pi: ExtensionAPI, manager?: ReminderManager): ReminderManager;
+export default function reminderHost(pi: ExtensionAPI): void;

package/dist/src/reminders/host.js

@@ -0,0 +1,298 @@
+import { Text, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { readUtilsConfigOrDefaults, utilsConfig } from "../utils-config.js";
+import { writeReminderDiagnostic } from "./debug.js";
+import { ReminderManager } from "./manager.js";
+import { DEBUG_REMINDER_SOURCE, LEGACY_REMINDER_MESSAGE_CUSTOM_TYPE, REMINDER_ANNOUNCE_NOW_EVENT, REMINDER_CLEAR_SOURCE_EVENT, REMINDER_LIST_EVENT, REMINDER_MESSAGE_CUSTOM_TYPE, REMINDER_REMOVE_EVENT, REMINDER_UPSERT_EVENT, } from "./types.js";
+/** Register the shared reminder host hooks and event listeners. */
+export function registerReminderHost(pi, manager = new ReminderManager()) {
+    const eventBus = pi.events;
+    let cfg = readUtilsConfigOrDefaults("reload").reminders;
+    const refreshConfig = () => {
+        cfg = readUtilsConfigOrDefaults("reload").reminders;
+    };
+    const debugShowAllInTui = () => isDebugModeEnabled(cfg);
+    writeReminderDiagnostic({
+        event: "reminder_extension_init",
+    });
+    writeReminderDiagnostic({
+        event: "reminder_extension_register_start",
+    });
+    eventBus.on(REMINDER_UPSERT_EVENT, (payload) => {
+        if (isRecord(payload))
+            manager.upsert(payload);
+    });
+    eventBus.on(REMINDER_REMOVE_EVENT, (payload) => {
+        if (isRecord(payload))
+            manager.remove(payload);
+    });
+    eventBus.on(REMINDER_CLEAR_SOURCE_EVENT, (payload) => {
+        if (isRecord(payload))
+            manager.clearSource(payload);
+    });
+    eventBus.on(REMINDER_ANNOUNCE_NOW_EVENT, (payload) => {
+        manager.forceAnnounce(isRecord(payload) ? payload : {});
+    });
+    eventBus.on(REMINDER_LIST_EVENT, (payload) => {
+        if (isRecord(payload) && typeof payload.resolve === "function") {
+            handleListRequest(manager, payload);
+        }
+    });
+    if (typeof pi.registerMessageRenderer === "function") {
+        const renderer = (message, _options, theme) => {
+            const details = isRecord(message.details) ? message.details : undefined;
+            const content = typeof details?.displayText === "string"
+                ? details.displayText
+                : stripSystemReminderWrapper(extractTextContent(message.content));
+            return new SystemReminderComponent(content, details, theme);
+        };
+        pi.registerMessageRenderer(REMINDER_MESSAGE_CUSTOM_TYPE, renderer);
+        pi.registerMessageRenderer(LEGACY_REMINDER_MESSAGE_CUSTOM_TYPE, renderer);
+    }
+    pi.on("session_start", (_event, ctx) => {
+        manager.clearSession();
+        refreshConfig();
+        writeReminderDiagnostic({
+            event: "reminder_session_start",
+            sessionId: getSessionId(ctx),
+            cwd: getCwd(ctx),
+            providerApi: getProviderApi(ctx),
+        });
+    });
+    pi.on("session_shutdown", () => {
+        manager.clearSession();
+    });
+    pi.on("turn_start", () => {
+        manager.advanceTurn();
+    });
+    pi.on("before_agent_start", (_event, ctx) => {
+        const announcement = manager.collectDueAnnouncement({ showHiddenInDisplay: debugShowAllInTui() });
+        if (!announcement)
+            return;
+        const message = buildReminderMessage(announcement, getContextUsage(ctx));
+        writeAnnouncementDiagnostic("reminder_history_message", message);
+        return { message };
+    });
+    pi.on("context", (_event, ctx) => {
+        const announcement = manager.collectDueAnnouncement({ showHiddenInDisplay: debugShowAllInTui() });
+        if (!announcement)
+            return;
+        const message = buildReminderMessage(announcement, getContextUsage(ctx));
+        writeAnnouncementDiagnostic("reminder_context_message", message);
+        pi.sendMessage(message, { deliverAs: "steer" });
+    });
+    pi.registerCommand("reminders", {
+        description: "Open reminders settings",
+        handler: async (_args, ctx) => {
+            refreshConfig();
+            const current = debugShowAllInTui() ? "on" : "off";
+            const choice = await ctx.ui.select("Reminders debug: show all in TUI", [`${current === "on" ? "[on]" : "on"}`, `${current === "off" ? "[off]" : "off"}`, "← Back"]);
+            if (!choice || choice === "← Back")
+                return;
+            cfg = utilsConfig.update({ reminders: { ...cfg, debugShowAllInTui: choice.includes("on") } }).reminders;
+            ctx.ui.notify(`Reminders debug show-all in TUI ${cfg.debugShowAllInTui ? "enabled" : "disabled"}`, "info");
+        },
+    });
+    pi.registerCommand("remind", {
+        description: "Add a debug system reminder",
+        handler: async (args, ctx) => {
+            const text = args.trim();
+            if (!text) {
+                ctx.ui.notify("Usage: /remind <text>", "warning");
+                return;
+            }
+            manager.upsert({
+                source: DEBUG_REMINDER_SOURCE,
+                id: "debug-command",
+                label: "Reminder",
+                text,
+                priority: 100,
+                ttl: "once",
+            });
+            ctx.ui.notify("Reminder added", "info");
+        },
+    });
+    writeReminderDiagnostic({
+        event: "reminder_extension_registered",
+        hasEvents: eventBus !== undefined,
+        hasRegisterCommand: typeof pi.registerCommand === "function",
+        hasRegisterMessageRenderer: typeof pi.registerMessageRenderer === "function",
+        hasOn: typeof pi.on === "function",
+    });
+    return manager;
+}
+export default function reminderHost(pi) {
+    try {
+        registerReminderHost(pi);
+    }
+    catch (error) {
+        writeReminderDiagnostic({
+            event: "reminder_extension_register_error",
+            errorName: error instanceof Error ? error.name : undefined,
+            errorMessage: error instanceof Error ? error.message : String(error),
+            errorStack: error instanceof Error ? error.stack : undefined,
+        });
+        throw error;
+    }
+}
+function handleListRequest(manager, request) {
+    try {
+        request.resolve(manager.snapshot(request.source));
+    }
+    catch (error) {
+        request.reject?.(error);
+    }
+}
+function isDebugModeEnabled(config) {
+    const value = process.env.PI_REMINDERS_DEBUG?.trim().toLowerCase();
+    if (value)
+        return value === "1" || value === "true" || value === "yes" || value === "on";
+    return config.debugShowAllInTui === true;
+}
+function buildReminderMessage(announcement, usage) {
+    const sources = [...new Set(announcement.reminders.map((reminder) => reminder.source))].sort();
+    const modelBody = includesDcpReminder(announcement.reminders)
+        ? appendContextUsageLine(stripSystemReminderWrapper(announcement.text), usage)
+        : stripSystemReminderWrapper(announcement.text);
+    const displayText = announcement.displayText && includesDcpReminder(announcement.displayReminders)
+        ? appendContextUsageLine(announcement.displayText, usage)
+        : announcement.displayText;
+    const content = `<system-reminder>\n${modelBody}\n</system-reminder>`;
+    return {
+        customType: REMINDER_MESSAGE_CUSTOM_TYPE,
+        content,
+        display: displayText !== null,
+        details: {
+            reminderCount: announcement.reminders.length,
+            sources,
+            displayText: displayText ?? undefined,
+        },
+    };
+}
+function writeAnnouncementDiagnostic(event, message) {
+    const details = message.details;
+    writeReminderDiagnostic({
+        event,
+        activeReminderCount: details?.reminderCount,
+        sources: details?.sources,
+        trailerChars: message.content.length,
+    });
+}
+function getContextUsage(ctx) {
+    if (!isRecord(ctx) || typeof ctx.getContextUsage !== "function")
+        return undefined;
+    try {
+        const usage = ctx.getContextUsage();
+        if (!isRecord(usage) || typeof usage.contextWindow !== "number")
+            return undefined;
+        const tokens = typeof usage.tokens === "number" ? usage.tokens : null;
+        return { tokens, contextWindow: usage.contextWindow };
+    }
+    catch {
+        return undefined;
+    }
+}
+function includesDcpReminder(reminders) {
+    return reminders.some((reminder) => {
+        const source = reminder.source.trim().toLowerCase();
+        return source === "dcp" || source === "pi-dynamic-context-pruning";
+    });
+}
+function appendContextUsageLine(displayText, usage) {
+    if (!usage)
+        return displayText;
+    const contextWindow = formatTokenCount(usage.contextWindow);
+    if (usage.tokens === null)
+        return `${displayText}\nContext: unknown / ${contextWindow} tokens.`;
+    const percent = usage.contextWindow > 0 ? Math.round((usage.tokens / usage.contextWindow) * 100) : 0;
+    return `${displayText}\nContext: ${formatTokenCount(usage.tokens)} / ${contextWindow} tokens (${percent}%).`;
+}
+function formatTokenCount(tokens) {
+    if (tokens >= 1_000_000)
+        return `${trimFixed(tokens / 1_000_000)}M`;
+    if (tokens >= 1_000)
+        return `${trimFixed(tokens / 1_000)}k`;
+    return String(tokens);
+}
+function trimFixed(value) {
+    return value.toFixed(value >= 10 ? 0 : 1).replace(/\.0$/, "");
+}
+function getProviderApi(ctx) {
+    return typeof ctx?.model?.api === "string" ? ctx.model.api : undefined;
+}
+function getSessionId(ctx) {
+    try {
+        return ctx?.sessionManager?.getSessionId?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+function getCwd(ctx) {
+    try {
+        return ctx?.sessionManager?.getCwd?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractTextContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}
+function stripSystemReminderWrapper(content) {
+    return content
+        .replace(/^\s*<system-reminder>\s*/i, "")
+        .replace(/\s*<\/system-reminder>\s*$/i, "")
+        .trim();
+}
+function padToWidth(line, width) {
+    return `${line}${" ".repeat(Math.max(0, width - visibleWidth(line)))}`;
+}
+const SYSTEM_REMINDER_MIN_BODY_WIDTH = 76;
+const SYSTEM_REMINDER_BODY_WIDTH_RATIO = 0.9;
+class SystemReminderComponent {
+    content;
+    details;
+    theme;
+    constructor(content, details, theme) {
+        this.content = content;
+        this.details = details;
+        this.theme = theme;
+    }
+    invalidate() { }
+    render(width) {
+        if (width < 3)
+            return [truncateToWidth("System Reminder", width)];
+        const availableBodyWidth = width - 2;
+        const preferredBodyWidth = Math.max(SYSTEM_REMINDER_MIN_BODY_WIDTH, Math.floor(availableBodyWidth * SYSTEM_REMINDER_BODY_WIDTH_RATIO));
+        const bodyWidth = Math.max(1, Math.min(availableBodyWidth, preferredBodyWidth));
+        const title = " System Reminder ";
+        const titleText = truncateToWidth(title, bodyWidth, "");
+        const border = (value) => this.theme.fg("accent", value);
+        const lines = [border(`╭${titleText}${"─".repeat(Math.max(0, bodyWidth - visibleWidth(titleText)))}╮`)];
+        const text = new Text(this.content, 0, 0);
+        for (const line of text.render(bodyWidth)) {
+            const truncated = truncateToWidth(line, bodyWidth, "");
+            lines.push(border("│") + padToWidth(truncated, bodyWidth) + border("│"));
+        }
+        const meta = [
+            this.details?.reminderCount !== undefined ? `${this.details.reminderCount} reminder${this.details.reminderCount === 1 ? "" : "s"}` : undefined,
+            this.details?.sources?.length ? this.details.sources.join(", ") : undefined,
+        ].filter(Boolean).join(" · ");
+        if (meta) {
+            const metaLine = truncateToWidth(this.theme.fg("dim", meta), bodyWidth, "");
+            lines.push(border("│") + padToWidth(metaLine, bodyWidth) + border("│"));
+        }
+        lines.push(border(`╰${"─".repeat(bodyWidth)}╯`));
+        return lines;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

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

@@ -1,5 +1,3 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { ReminderManager } from "./manager.ts";
-/** Register the pi-reminders extension hooks and event listeners. */
-export declare function registerReminderHost(pi: ExtensionAPI, manager?: ReminderManager): ReminderManager;
-export default function reminderHost(pi: ExtensionAPI): void;
+export { default, registerReminderHost } from "./host.ts";
+export { remindersConfigSchema, type RemindersConfig } from "./config.ts";
+export * from "./types.ts";