@oh-my-pi/pi-utils 17.2.9 → 17.2.11

package/dist/types/acp/schema.d.ts

@@ -0,0 +1,41 @@
+import type { ForkSessionResponse, LoadSessionResponse, NewSessionResponse, PromptResponse, SessionNotification } from "./protocol.js";
+/** Validation failure compatible with the used Zod error surface. */
+export interface ValidationError {
+    issues: Array<{
+        path: Array<string | number>;
+        message: string;
+    }>;
+}
+/** Successful validation result. */
+export interface ValidationSuccess<T> {
+    success: true;
+    data: T;
+}
+/** Failed validation result. */
+export interface ValidationFailure {
+    success: false;
+    error: ValidationError;
+}
+/** Runtime validator compatible with the used schema call shape. */
+export interface Validator<T> {
+    safeParse(value: unknown): ValidationSuccess<T> | ValidationFailure;
+    parse(value: unknown): T;
+}
+/** Validator for new-session responses. */
+export declare const zNewSessionResponse: Validator<NewSessionResponse>;
+/** Validator for load-session responses. */
+export declare const zLoadSessionResponse: Validator<LoadSessionResponse>;
+/** Validator for fork-session responses. */
+export declare const zForkSessionResponse: Validator<ForkSessionResponse>;
+/** Validator for prompt responses. */
+export declare const zPromptResponse: Validator<PromptResponse>;
+/** Validator for session notifications. */
+export declare const zSessionNotification: Validator<SessionNotification>;
+/** ACP runtime validators. */
+export declare const schema: {
+    readonly zNewSessionResponse: Validator<NewSessionResponse>;
+    readonly zLoadSessionResponse: Validator<LoadSessionResponse>;
+    readonly zForkSessionResponse: Validator<ForkSessionResponse>;
+    readonly zPromptResponse: Validator<PromptResponse>;
+    readonly zSessionNotification: Validator<SessionNotification>;
+};

package/dist/types/acp/stream.d.ts

@@ -0,0 +1,8 @@
+import type { AnyMessage } from "./transport.js";
+/** Bidirectional JSON-RPC message transport. */
+export interface Stream {
+    writable: WritableStream<AnyMessage>;
+    readable: ReadableStream<AnyMessage>;
+}
+/** Converts byte-oriented newline-delimited JSON streams to an ACP message transport. */
+export declare function ndJsonStream(output: WritableStream<Uint8Array>, input: ReadableStream<Uint8Array>): Stream;

package/dist/types/acp/transport.d.ts

@@ -0,0 +1,81 @@
+import type { MaybePromise } from "./protocol.js";
+import type { Stream } from "./stream.js";
+/** JSON-RPC request identifier. */
+export type JsonRpcId = string | number | null;
+/** JSON-RPC request. */
+export interface AnyRequest {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+/** JSON-RPC notification. */
+export interface AnyNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+/** JSON-RPC error payload. */
+export interface ErrorResponse {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** JSON-RPC response. */
+export type AnyResponse = {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+} & ({
+    result: unknown;
+} | {
+    error: ErrorResponse;
+});
+/** Any JSON-RPC wire message. */
+export type AnyMessage = AnyRequest | AnyNotification | AnyResponse;
+/** Error returned by a JSON-RPC peer or handler. */
+export declare class RequestError extends Error {
+    /** JSON-RPC error code. */
+    readonly code: number;
+    /** Optional protocol error data. */
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+    /** Creates a JSON parse error. */
+    static parseError(data?: unknown, additionalMessage?: string): RequestError;
+    /** Creates an invalid-request error. */
+    static invalidRequest(data?: unknown, additionalMessage?: string): RequestError;
+    /** Creates a method-not-found error. */
+    static methodNotFound(method: string): RequestError;
+    /** Creates an invalid-parameters error. */
+    static invalidParams(data?: unknown, additionalMessage?: string): RequestError;
+    /** Creates an internal error. */
+    static internalError(data?: unknown, additionalMessage?: string): RequestError;
+    /** Creates a cancellation error. */
+    static requestCancelled(data?: unknown, additionalMessage?: string): RequestError;
+    /** Creates an authentication-required error. */
+    static authRequired(data?: unknown, additionalMessage?: string): RequestError;
+    /** Creates a resource-not-found error. */
+    static resourceNotFound(uri?: string): RequestError;
+    /** Converts this error into a JSON-RPC result. */
+    toResult(): {
+        error: ErrorResponse;
+    };
+    /** Converts this error into a JSON-RPC error payload. */
+    toErrorResponse(): ErrorResponse;
+}
+type Dispatcher = (method: string, params: unknown, notification: boolean) => MaybePromise<unknown>;
+/** Correlated bidirectional JSON-RPC connection. */
+export declare class RpcConnection {
+    #private;
+    constructor(stream: Stream, dispatcher: Dispatcher);
+    /** Signal aborted when the stream closes. */
+    get signal(): AbortSignal;
+    /** Promise resolved when the stream closes. */
+    get closed(): Promise<void>;
+    /** Sends a correlated JSON-RPC request. */
+    request<Response>(method: string, params?: unknown): Promise<Response>;
+    /** Sends a JSON-RPC notification. */
+    notify(method: string, params?: unknown): Promise<void>;
+    /** Closes the connection and rejects outstanding requests. */
+    close(error?: unknown): void;
+}
+export {};

package/dist/types/acp.d.ts

@@ -0,0 +1,6 @@
+/** Behavior-compatible reimplementation of @agentclientprotocol/sdk's used surface. */
+export * from "./acp/connection.js";
+export * from "./acp/protocol.js";
+export * from "./acp/schema.js";
+export * from "./acp/stream.js";
+export * from "./acp/transport.js";

package/dist/types/browsers.d.ts

@@ -0,0 +1,68 @@
+/** Behavior-compatible reimplementation of @puppeteer/browsers' used surface. */
+/** Supported browser products. */
+export declare enum Browser {
+    CHROME = "chrome",
+    CHROMEHEADLESSSHELL = "chrome-headless-shell",
+    CHROMIUM = "chromium",
+    FIREFOX = "firefox",
+    CHROMEDRIVER = "chromedriver"
+}
+/** Browser download platform identifiers. */
+export declare enum BrowserPlatform {
+    LINUX = "linux",
+    LINUX_ARM = "linux_arm",
+    MAC = "mac",
+    MAC_ARM = "mac_arm",
+    WIN32 = "win32",
+    WIN64 = "win64"
+}
+/** Chrome-for-Testing release channel tags accepted by {@link resolveBuildId}. */
+export declare enum BrowserTag {
+    CANARY = "canary",
+    NIGHTLY = "nightly",
+    BETA = "beta",
+    DEV = "dev",
+    DEVEDITION = "devedition",
+    STABLE = "stable",
+    ESR = "esr",
+    LATEST = "latest"
+}
+/** Download progress reported while a browser archive is streamed to disk. */
+export interface BrowserDownloadProgress {
+    downloadedBytes: number;
+    totalBytes: number;
+}
+/** Inputs used to locate an installed browser executable. */
+export interface ComputeExecutablePathOptions {
+    browser: Browser;
+    buildId: string;
+    cacheDir: string;
+    platform?: BrowserPlatform;
+}
+/** Inputs used to download and install a browser. */
+export interface InstallOptions extends ComputeExecutablePathOptions {
+    baseUrl?: string;
+    downloadProgressCallback?: (progress: BrowserDownloadProgress) => void;
+}
+/** Metadata for one browser installation found in a Puppeteer cache. */
+export interface InstalledBrowser {
+    browser: Browser;
+    buildId: string;
+    platform: BrowserPlatform;
+    path: string;
+    executablePath: string;
+}
+/** Detect the current host's Puppeteer browser platform. */
+export declare function detectBrowserPlatform(): BrowserPlatform | undefined;
+/** Resolve a Chrome-for-Testing channel, milestone, or build prefix to a full build ID. */
+export declare function resolveBuildId(browser: Browser, _platform: BrowserPlatform, tag: string | BrowserTag): Promise<string>;
+/** Return the Chrome-for-Testing archive URL for a browser build. */
+export declare function getDownloadUrl(browser: Browser, platform: BrowserPlatform, buildId: string, baseUrl?: string): URL;
+/** Compute the executable path in Puppeteer's cache layout. */
+export declare function computeExecutablePath(options: ComputeExecutablePathOptions): string;
+/** Scan a Puppeteer cache for browser installation directories. */
+export declare function getInstalledBrowsers(options: {
+    cacheDir: string;
+}): Promise<InstalledBrowser[]>;
+/** Download and unpack Chrome into Puppeteer's existing cache layout. */
+export declare function install(options: InstallOptions): Promise<InstalledBrowser>;

package/dist/types/chalk.d.ts

@@ -0,0 +1,125 @@
+/** Behavior-compatible reimplementation of chalk's used surface. */
+/** ANSI color capability level. */
+export type ColorLevel = 0 | 1 | 2 | 3;
+/** Details about a terminal's supported color depth. */
+export interface ColorSupport {
+    /** Highest supported ANSI color level. */
+    level: ColorLevel;
+    /** Whether the terminal supports the basic 16 colors. */
+    hasBasic: boolean;
+    /** Whether the terminal supports the 256-color palette. */
+    has256: boolean;
+    /** Whether the terminal supports 24-bit color. */
+    has16m: boolean;
+}
+interface ChalkOptions {
+    level?: ColorLevel;
+}
+/** A callable, chainable ANSI text formatter. */
+export interface ChalkInstance {
+    (...text: unknown[]): string;
+    /** Active color capability level. */
+    level: ColorLevel;
+    /** Reset every active terminal style. */
+    readonly reset: ChalkInstance;
+    /** Render bold text. */
+    readonly bold: ChalkInstance;
+    /** Render faint text. */
+    readonly dim: ChalkInstance;
+    /** Render italic text. */
+    readonly italic: ChalkInstance;
+    /** Render underlined text. */
+    readonly underline: ChalkInstance;
+    /** Swap foreground and background colors. */
+    readonly inverse: ChalkInstance;
+    /** Render struck-through text. */
+    readonly strikethrough: ChalkInstance;
+    /** Render black text. */
+    readonly black: ChalkInstance;
+    /** Render red text. */
+    readonly red: ChalkInstance;
+    /** Render green text. */
+    readonly green: ChalkInstance;
+    /** Render yellow text. */
+    readonly yellow: ChalkInstance;
+    /** Render blue text. */
+    readonly blue: ChalkInstance;
+    /** Render magenta text. */
+    readonly magenta: ChalkInstance;
+    /** Render cyan text. */
+    readonly cyan: ChalkInstance;
+    /** Render white text. */
+    readonly white: ChalkInstance;
+    /** Render gray text. */
+    readonly gray: ChalkInstance;
+    /** Alias for gray text. */
+    readonly grey: ChalkInstance;
+    /** Render bright black text. */
+    readonly blackBright: ChalkInstance;
+    /** Render bright red text. */
+    readonly redBright: ChalkInstance;
+    /** Render bright green text. */
+    readonly greenBright: ChalkInstance;
+    /** Render bright yellow text. */
+    readonly yellowBright: ChalkInstance;
+    /** Render bright blue text. */
+    readonly blueBright: ChalkInstance;
+    /** Render bright magenta text. */
+    readonly magentaBright: ChalkInstance;
+    /** Render bright cyan text. */
+    readonly cyanBright: ChalkInstance;
+    /** Render bright white text. */
+    readonly whiteBright: ChalkInstance;
+    /** Render text on a black background. */
+    readonly bgBlack: ChalkInstance;
+    /** Render text on a red background. */
+    readonly bgRed: ChalkInstance;
+    /** Render text on a green background. */
+    readonly bgGreen: ChalkInstance;
+    /** Render text on a yellow background. */
+    readonly bgYellow: ChalkInstance;
+    /** Render text on a blue background. */
+    readonly bgBlue: ChalkInstance;
+    /** Render text on a magenta background. */
+    readonly bgMagenta: ChalkInstance;
+    /** Render text on a cyan background. */
+    readonly bgCyan: ChalkInstance;
+    /** Render text on a white background. */
+    readonly bgWhite: ChalkInstance;
+    /** Render text on a gray background. */
+    readonly bgGray: ChalkInstance;
+    /** Alias for a gray background. */
+    readonly bgGrey: ChalkInstance;
+    /** Render text on a bright black background. */
+    readonly bgBlackBright: ChalkInstance;
+    /** Render text on a bright red background. */
+    readonly bgRedBright: ChalkInstance;
+    /** Render text on a bright green background. */
+    readonly bgGreenBright: ChalkInstance;
+    /** Render text on a bright yellow background. */
+    readonly bgYellowBright: ChalkInstance;
+    /** Render text on a bright blue background. */
+    readonly bgBlueBright: ChalkInstance;
+    /** Render text on a bright magenta background. */
+    readonly bgMagentaBright: ChalkInstance;
+    /** Render text on a bright cyan background. */
+    readonly bgCyanBright: ChalkInstance;
+    /** Render text on a bright white background. */
+    readonly bgWhiteBright: ChalkInstance;
+    /** Render text with an arbitrary hexadecimal foreground color. */
+    hex(color: string): ChalkInstance;
+}
+/** Constructor for an independently configured chalk formatter. */
+export interface ChalkConstructor {
+    new (options?: ChalkOptions): ChalkInstance;
+}
+/** Detect an ANSI color level from terminal environment and TTY state. */
+export declare function detectColorLevel(environment: NodeJS.ProcessEnv, isTTY: boolean): ColorLevel;
+/** Color support detected for standard output. */
+export declare const supportsColor: false | ColorSupport;
+/** Color support detected for standard error. */
+export declare const supportsColorStderr: false | ColorSupport;
+/** Construct an independently configured chalk formatter. */
+export declare const Chalk: ChalkConstructor;
+declare const chalk: ChalkInstance;
+export default chalk;

package/dist/types/dates.d.ts

@@ -0,0 +1,7 @@
+/** Behavior-compatible reimplementation of date-fns's used surface. */
+/** Format a date with the supported date-fns v4 tokens and quoted literals. */
+export declare function format(value: Date | number, pattern: string): string;
+/** Describe the distance from a date to now using date-fns's English thresholds. */
+export declare function formatDistanceToNow(value: Date | number, options?: {
+    addSuffix?: boolean;
+}): string;

package/dist/types/docx/converter.d.ts

@@ -0,0 +1,46 @@
+/** A mammoth-compatible diagnostic emitted while converting a document. */
+export interface DocxMessage {
+    readonly type: "warning" | "error";
+    readonly message: string;
+}
+/** The HTML and diagnostics produced by a DOCX conversion. */
+export interface DocxResult {
+    readonly value: string;
+    readonly messages: DocxMessage[];
+}
+/** An in-memory or filesystem DOCX input. */
+export type DocxInput = {
+    readonly buffer: Uint8Array;
+    readonly path?: never;
+} | {
+    readonly path: string;
+    readonly buffer?: never;
+};
+/** An image exposed to a custom image converter. */
+export interface DocxImage {
+    readonly contentType: string;
+    readonly altText: string;
+    /** Read the image payload using mammoth's used encoding surface. */
+    read(encoding: "base64"): Promise<string>;
+}
+/** HTML attributes returned by a custom image converter. */
+export type ImageAttributes = Readonly<Record<string, string>>;
+/** A callback that maps an embedded DOCX image to HTML attributes. */
+export type ImageAttributeConverter = (image: DocxImage) => ImageAttributes | Promise<ImageAttributes>;
+/** An image converter created by `images.imgElement`. */
+export interface ImageConverter {
+    readonly convert: ImageAttributeConverter;
+}
+/** Options supported by the behavior-compatible DOCX converter. */
+export interface ConvertToHtmlOptions {
+    readonly convertImage?: ImageConverter;
+    readonly styleMap?: string | readonly string[];
+    readonly includeDefaultStyleMap?: boolean;
+}
+/** Mammoth-shaped helpers for configuring embedded image conversion. */
+export declare const images: {
+    /** Wrap an image-to-attributes callback for `convertToHtml`. */
+    imgElement(convert: ImageAttributeConverter): ImageConverter;
+};
+/** Convert a DOCX buffer or path to mammoth-compatible HTML. */
+export declare function convertToHtml(input: DocxInput, options?: ConvertToHtmlOptions): Promise<DocxResult>;

package/dist/types/docx/xml.d.ts

@@ -0,0 +1,26 @@
+interface XmlText {
+    readonly kind: "text";
+    readonly value: string;
+}
+/** A minimal XML element used by the DOCX reader. */
+export interface XmlElement {
+    readonly kind: "element";
+    readonly name: string;
+    readonly attributes: ReadonlyMap<string, string>;
+    readonly children: readonly XmlNode[];
+}
+/** A node in the DOCX reader's minimal XML tree. */
+export type XmlNode = XmlElement | XmlText;
+/** Return the namespace-independent part of an XML qualified name. */
+export declare function localName(name: string): string;
+/** Parse XML into a small namespace-tolerant element tree. */
+export declare function parseXml(source: string): XmlElement;
+/** Return direct element children, optionally filtered by local name. */
+export declare function childElements(element: XmlElement, name?: string): XmlElement[];
+/** Return the first direct child with the given local name. */
+export declare function firstChild(element: XmlElement | undefined, name: string): XmlElement | undefined;
+/** Return an attribute by qualified or namespace-independent name. */
+export declare function attribute(element: XmlElement | undefined, name: string): string | undefined;
+/** Return all descendant elements with a given local name. */
+export declare function descendants(element: XmlElement, name: string): XmlElement[];
+export {};

package/dist/types/docx/zip.d.ts

@@ -0,0 +1,6 @@
+/** The decompressed members of a DOCX ZIP package. */
+export type ZipEntries = ReadonlyMap<string, Uint8Array>;
+/** Decode a ZIP package by walking its central directory. */
+export declare function readZip(bytes: Uint8Array): ZipEntries;
+/** Decode a ZIP member as UTF-8 text. */
+export declare function readZipText(entries: ZipEntries, name: string): string | undefined;

package/dist/types/docx.d.ts

@@ -0,0 +1,11 @@
+/** Behavior-compatible reimplementation of mammoth's used surface. */
+export { type ConvertToHtmlOptions, convertToHtml, type DocxImage, type DocxInput, type DocxMessage, type DocxResult, type ImageAttributeConverter, type ImageAttributes, type ImageConverter, images, } from "./docx/converter.js";
+import { convertToHtml } from "./docx/converter.js";
+/** Mammoth-shaped default export for drop-in consumer imports. */
+declare const docx: {
+    convertToHtml: typeof convertToHtml;
+    images: {
+        imgElement(convert: import("./docx.js").ImageAttributeConverter): import("./docx.js").ImageConverter;
+    };
+};
+export default docx;