webfox 0.0.0-test.0 → 4.0.0

package/dist/configuration/defaults.d.ts

@@ -0,0 +1,3 @@
+import { type Capability, type ProviderId } from "../domain.js";
+import { type ConfigPathOptions } from "./file.js";
+export declare function setCapabilityDefault(capability: Capability, provider: ProviderId, options?: ConfigPathOptions): Promise<string>;

package/dist/configuration/file.d.ts

@@ -0,0 +1,17 @@
+import { CONFIG_SCHEMA_URL } from "../package-metadata.js";
+import type { WebfoxConfig } from "./types.js";
+export { CONFIG_SCHEMA_URL };
+export interface ConfigPathOptions {
+    configPath?: string;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    platform?: NodeJS.Platform;
+    home?: string;
+}
+export declare function resolveConfigPath(options?: ConfigPathOptions): string;
+export declare function loadConfig(options?: ConfigPathOptions): Promise<WebfoxConfig>;
+export declare function loadConfigSync(options?: ConfigPathOptions): WebfoxConfig;
+export declare function parseConfigDocument(text: string, source?: string): import("yaml").Document.Parsed<import("yaml").Scalar.Parsed, true> | import("yaml").Document.Parsed<import("yaml").YAMLSeq.Parsed<import("yaml").ParsedNode>, true> | import("yaml").Document.Parsed<import("yaml").YAMLMap.Parsed<import("yaml").ParsedNode, import("yaml").ParsedNode | null>, true> | import("yaml").Document.Parsed<import("yaml").Alias.Parsed, true>;
+export declare function parseConfig(text: string, source?: string): WebfoxConfig;
+export declare function validateConfig(value: unknown, source?: string): WebfoxConfig;
+export declare function redactConfig(config: WebfoxConfig): unknown;

package/dist/configuration/options-schema.d.ts

@@ -0,0 +1,2 @@
+import type { TObject } from "typebox";
+export declare function buildOptionSchema(providerSchema?: TObject): TObject<import("typebox").TProperties> | undefined;

package/dist/configuration/planning.d.ts

@@ -0,0 +1,10 @@
+import type { TObject } from "typebox";
+import { type Capability, type ProviderId } from "../domain.js";
+import type { ProviderDefinition } from "../providers/definition.js";
+import type { WebfoxConfig } from "./types.js";
+export declare function selectProvider(config: WebfoxConfig, capability: Capability, requested?: ProviderId): ProviderDefinition;
+export declare function optionSchema(definition: ProviderDefinition, capability: Capability, mode?: "request" | "defaults"): TObject | undefined;
+export declare function effectiveOptions(config: WebfoxConfig, definition: ProviderDefinition, capability: Capability, options?: Record<string, unknown>, mode?: "request" | "defaults"): Record<string, unknown>;
+export declare function validateOptions(definition: ProviderDefinition, capability: Capability, options: Record<string, unknown>, mode?: "request" | "defaults"): void;
+export declare function validateConfiguredOptions(config: WebfoxConfig): void;
+export declare function deepMerge(base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown>;

package/dist/configuration/schema.d.ts

@@ -0,0 +1,9 @@
+/** Generated from the same lightweight definitions as help and planning. */
+export declare const configurationSchema: {
+    type: string;
+    additionalProperties: boolean;
+    properties: Record<string, unknown>;
+    $schema: string;
+    $id: string;
+    title: string;
+};

package/dist/configuration/types.d.ts

@@ -0,0 +1,37 @@
+import type { Capability, ProviderId } from "../domain.js";
+export type CredentialSource = {
+    env: string;
+} | {
+    command: [string, ...string[]];
+} | {
+    value: string;
+};
+export interface ExecutionConfig {
+    timeoutMs?: number;
+    researchTimeoutMs?: number;
+    retries?: number;
+    retryDelayMs?: number;
+    concurrency?: number;
+}
+export interface CapabilityDefault {
+    provider?: ProviderId;
+    maxResults?: number;
+}
+export interface CustomCommand {
+    argv: [string, ...string[]];
+    cwd?: string;
+    env?: Record<string, CredentialSource>;
+}
+export interface ProviderConfiguration {
+    credentials?: Record<string, CredentialSource>;
+    baseUrl?: string;
+    accountId?: CredentialSource;
+    options?: Partial<Record<Capability, Record<string, unknown>>>;
+    commands?: Partial<Record<Capability, CustomCommand>>;
+}
+export interface WebfoxConfig {
+    $schema?: string;
+    defaults?: Partial<Record<Capability, CapabilityDefault>>;
+    execution?: ExecutionConfig;
+    providers?: Partial<Record<ProviderId, ProviderConfiguration>>;
+}

package/dist/contents.d.ts

@@ -0,0 +1,19 @@
+import type { ContentsAnswer as DocumentContents, ProviderId, SerializedError } from "./domain.js";
+/** Internal normalized page, before the adapter associates its request index. */
+export interface ContentsAnswer extends DocumentContents {
+    error?: string | SerializedError;
+    inputIndex?: number;
+}
+export interface ContentsResponse {
+    provider: ProviderId;
+    answers: ContentsAnswer[];
+}
+export interface IndexedContentsResponse {
+    provider: ProviderId;
+    answers: Array<DocumentContents & {
+        inputIndex: number;
+        error?: SerializedError;
+    }>;
+}
+/** Only adapters that themselves assemble pages in request order use this helper. */
+export declare function orderedContents(response: ContentsResponse): IndexedContentsResponse;

package/dist/domain.d.ts

@@ -0,0 +1,89 @@
+export declare const CAPABILITIES: readonly ["search", "contents", "answer", "research"];
+export type Capability = (typeof CAPABILITIES)[number];
+export declare const PROVIDER_IDS: readonly ["brave", "cloudflare", "custom", "exa", "firecrawl", "gemini", "linkup", "ollama", "openai", "parallel", "perplexity", "serper", "tavily", "valyu"];
+export type ProviderId = (typeof PROVIDER_IDS)[number];
+export declare const WEBFOX_ERROR_CODES: readonly ["INVALID_CONFIG", "INVALID_INPUT", "PROVIDER_UNAVAILABLE", "PROVIDER_FAILURE", "PARTIAL_BATCH", "TIMEOUT", "CANCELLED"];
+export type WebfoxErrorCode = (typeof WEBFOX_ERROR_CODES)[number];
+export interface SerializedError {
+    code: WebfoxErrorCode;
+    message: string;
+    retryable?: boolean;
+}
+export type InputResult<T> = {
+    input: string;
+    ok: true;
+    value: T;
+} | {
+    input: string;
+    ok: false;
+    error: SerializedError;
+};
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    score?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ContentsAnswer {
+    /** Final fetched URL; association with the requested URL is in InputResult.input. */
+    url: string;
+    content?: string;
+    summary?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface TextAnswer {
+    text: string;
+    itemCount?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface CapabilityValues {
+    search: {
+        results: SearchResult[];
+    };
+    contents: ContentsAnswer;
+    answer: TextAnswer;
+    research: TextAnswer;
+}
+export interface CapabilityDocument<T, C extends Capability = Capability> {
+    schemaVersion: 1;
+    capability: C;
+    provider: ProviderId;
+    status: "ok" | "partial";
+    results: InputResult<T>[];
+}
+export type SearchDocument = CapabilityDocument<CapabilityValues["search"], "search">;
+export type ContentsDocument = CapabilityDocument<ContentsAnswer, "contents">;
+export type AnswerDocument = CapabilityDocument<TextAnswer, "answer">;
+export type ResearchDocument = CapabilityDocument<TextAnswer, "research">;
+export type WebDocument = SearchDocument | ContentsDocument | AnswerDocument | ResearchDocument;
+export interface ProgressEvent {
+    capability: Capability;
+    provider: ProviderId;
+    message: string;
+    /** Per-input lifecycle updates, indexed by original input order. */
+    inputIndex?: number;
+    input?: string;
+    state?: "queued" | "running" | "done" | "failed" | "cancelled";
+}
+export interface RequestOptions {
+    provider?: ProviderId;
+    options?: Record<string, unknown>;
+    /** Overall operation deadline, including preparation and retries. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onProgress?: (event: ProgressEvent) => void;
+}
+export interface SearchOptions extends RequestOptions {
+    queries: string[];
+    maxResults?: number;
+}
+export interface ContentsOptions extends RequestOptions {
+    urls: string[];
+}
+export interface AnswerOptions extends RequestOptions {
+    queries: string[];
+}
+export interface ResearchOptions extends RequestOptions {
+    input: string;
+}

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+import type { SerializedError, WebfoxErrorCode } from "./domain.js";
+export declare class WebfoxError extends Error {
+    readonly code: WebfoxErrorCode;
+    readonly options: {
+        cause?: unknown;
+        retryable?: boolean;
+    };
+    readonly name = "WebfoxError";
+    constructor(code: WebfoxErrorCode, message: string, options?: {
+        cause?: unknown;
+        retryable?: boolean;
+    });
+    toJSON(): SerializedError;
+}
+/** Classify structured transport/SDK fields, never error-message substrings. */
+export declare function asWebfoxError(error: unknown): WebfoxError;
+export declare function httpError(response: Response, message: string): WebfoxError;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createWebfox } from "./application.js";
+export { CONFIG_SCHEMA_URL, loadConfig, parseConfig, redactConfig, resolveConfigPath, validateConfig, } from "./configuration/file.js";
+export { setCapabilityDefault } from "./configuration/defaults.js";
+export { validateConfiguredOptions } from "./configuration/planning.js";
+export { WebfoxError } from "./errors.js";
+export * from "./domain.js";
+export type * from "./application-types.js";
+export type * from "./configuration/types.js";

package/dist/index.js

@@ -0,0 +1,38 @@
+import {
+  createWebfox,
+  loadConfig,
+  parseConfig,
+  redactConfig,
+  resolveConfigPath,
+  setCapabilityDefault,
+  validateConfig
+} from "./chunk-SMF5ALX7.js";
+import "./chunk-WCTOYZVB.js";
+import {
+  CONFIG_SCHEMA_URL,
+  validateConfiguredOptions
+} from "./chunk-L425U55P.js";
+import "./chunk-ZVTVERW5.js";
+import {
+  CAPABILITIES,
+  PROVIDER_IDS,
+  WEBFOX_ERROR_CODES
+} from "./chunk-G2YAQEET.js";
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+export {
+  CAPABILITIES,
+  CONFIG_SCHEMA_URL,
+  PROVIDER_IDS,
+  WEBFOX_ERROR_CODES,
+  WebfoxError,
+  createWebfox,
+  loadConfig,
+  parseConfig,
+  redactConfig,
+  resolveConfigPath,
+  setCapabilityDefault,
+  validateConfig,
+  validateConfiguredOptions
+};

package/dist/package-metadata.d.ts

@@ -0,0 +1,3 @@
+export declare const PACKAGE_NAME: string;
+export declare const PACKAGE_VERSION: string;
+export declare const CONFIG_SCHEMA_URL: string;

package/dist/pi-keybindings.d.ts

@@ -0,0 +1 @@
+export declare function expansionKey(): string;

package/dist/pi-params.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./domain.js";
+/** Show only explicit call choices, not configured or provider defaults. */
+export declare function callParameters(capability: Capability, args: Record<string, unknown>, formatKey?: (key: string) => string): string;

package/dist/pi-render.d.ts

@@ -0,0 +1,50 @@
+import { type Theme } from "@earendil-works/pi-coding-agent";
+import { type Component } from "@earendil-works/pi-tui";
+import type { Capability } from "./domain.js";
+declare const inputStates: {
+    readonly queued: {
+        readonly glyph: "●";
+        readonly color: "dim";
+    };
+    readonly running: {
+        readonly glyph: "▶︎";
+        readonly color: "warning";
+    };
+    readonly done: {
+        readonly glyph: "✔︎";
+        readonly color: "success";
+    };
+    readonly failed: {
+        readonly glyph: "✘︎";
+        readonly color: "error";
+    };
+    readonly cancelled: {
+        readonly glyph: "■";
+        readonly color: "dim";
+    };
+};
+export interface InputStatus {
+    input: string;
+    state: keyof typeof inputStates;
+}
+export declare class WebCall implements Component {
+    private readonly capability;
+    private args;
+    private theme;
+    private expanded;
+    constructor(capability: Capability);
+    update(args: unknown, theme: Theme, expanded: boolean): void;
+    render(width: number): string[];
+    invalidate(): void;
+}
+export declare function renderWebResult(result: {
+    content: {
+        type: string;
+        text?: string;
+    }[];
+    details?: unknown;
+}, options: {
+    expanded: boolean;
+    isPartial: boolean;
+}, theme: Theme, isError: boolean, capability?: Capability): Component;
+export {};

package/dist/pi-search-render.d.ts

@@ -0,0 +1,4 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component } from "@earendil-works/pi-tui";
+/** Search excerpts are text, not documents. Never parse their Markdown. */
+export declare function renderSearchResult(details: unknown, fallback: string, theme: Theme): Component;

package/dist/pi-text.d.ts

@@ -0,0 +1,4 @@
+/** Pi's shell owns the background; truncation must not reset it. */
+export declare function truncateLine(text: string, width: number): string;
+/** Keep source punctuation literal and remove terminal control sequences. */
+export declare function plainText(value: string): string;

package/dist/pi-validation.d.ts

@@ -0,0 +1,4 @@
+import type { TSchema } from "typebox";
+/** Reject unknown fields before Pi's generic validator echoes the raw payload.
+ * Leave coercion, required fields, and all other validation to Pi unchanged. */
+export declare function prepareToolArguments(schema: TSchema, args: unknown): unknown;

package/dist/pi.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function webExtension(pi: ExtensionAPI): void;